# -*- 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.async_support.base.exchange import Exchange
from ccxt.abstract.arkham import ImplicitAPI
import hashlib
from ccxt.base.types import Account, Any, Balances, Currencies, Currency, DepositAddress, Int, Leverage, LeverageTier, LeverageTiers, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFees, 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 BadSymbol
from ccxt.base.errors import OperationRejected
from ccxt.base.errors import InsufficientFunds
from ccxt.base.errors import InvalidAddress
from ccxt.base.errors import InvalidOrder
from ccxt.base.errors import OrderNotFound
from ccxt.base.errors import OperationFailed
from ccxt.base.errors import RateLimitExceeded
from ccxt.base.decimal_to_precision import TICK_SIZE
from ccxt.base.precise import Precise


class arkham(Exchange, ImplicitAPI):

    def describe(self) -> Any:
        return self.deep_extend(super(arkham, self).describe(), {
            'id': 'arkham',
            'name': 'ARKHAM',
            'countries': ['US'],
            'version': 'v1',
            'rateLimit': 20 / 3,  # 150 req/s
            'certified': False,
            'pro': True,
            'has': {
                'CORS': False,
                'spot': True,
                'margin': False,
                'swap': True,
                'future': False,
                'option': False,
                'borrowCrossMargin': False,
                'borrowIsolatedMargin': False,
                'borrowMargin': False,
                'cancelAllOrders': True,
                'cancelOrder': True,
                'createDepositAddress': True,
                'createOrder': True,
                'fetchAccounts': True,
                'fetchAllGreeks': False,
                'fetchBalance': True,
                'fetchBorrowInterest': False,
                'fetchBorrowRate': False,
                'fetchBorrowRateHistories': False,
                'fetchBorrowRateHistory': False,
                'fetchBorrowRates': False,
                'fetchBorrowRatesPerSymbol': False,
                'fetchClosedOrders': True,
                'fetchCrossBorrowRate': False,
                'fetchCrossBorrowRates': False,
                'fetchCurrencies': True,
                'fetchDepositAddress': False,
                'fetchDepositAddressesByNetwork': True,
                'fetchDeposits': True,
                'fetchFundingHistory': True,
                'fetchGreeks': False,
                'fetchIsolatedBorrowRate': False,
                'fetchIsolatedBorrowRates': False,
                'fetchLeverage': True,
                'fetchLeverageTiers': True,
                'fetchMyTrades': True,
                'fetchOHLCV': True,
                'fetchOpenOrders': True,
                'fetchOption': False,
                'fetchOptionChain': False,
                'fetchOrder': True,
                'fetchOrderBook': True,
                'fetchPositions': True,
                'fetchTicker': True,
                'fetchTickers': True,
                'fetchTime': True,
                'fetchTrades': True,
                'fetchTradingFees': True,
                'fetchVolatilityHistory': False,
                'fetchWithdrawals': True,
                'repayCrossMargin': False,
                'repayIsolatedMargin': False,
                'sandbox': False,
                'setLeverage': True,
                'withdraw': True,
            },
            'timeframes': {
                # enums are wrong in DOCS, these string values need to be in request
                '1m': '1m',
                '5m': '5m',
                '15m': '15m',
                '30m': '30m',
                '1h': '1h',
                '6h': '6h',
                '1d': '24h',
            },
            'urls': {
                'logo': 'https://github.com/user-attachments/assets/5cefdcfb-2c10-445b-835c-fa21317bf5ac',
                'api': {
                    'v1': 'https://arkm.com/api',
                },
                'www': 'https://arkm.com/',
                'referral': {
                    'url': 'https://arkm.com/register?ref=ccxt',
                    'discount': 0,
                },
                'doc': [
                    'https://arkm.com/limits-api',
                    'https://info.arkm.com/api-platform',
                ],
                'fees': 'https://arkm.com/fees',
            },
            'api': {
                'v1': {
                    'public': {
                        'get': {
                            'alerts': 1,
                            'announcements': 1,
                            'assets': 1,
                            'book': 1,
                            'candles': 1,
                            'chains': 1,
                            'contracts': 1,
                            'index-price': 1,
                            'index-prices': 1,
                            'margin-schedules': 1,
                            'marketcapchart': 1,
                            'marketcaps': 1,
                            'pair': 1,
                            'pairs': 1,
                            'server-time': 1,
                            'ticker': 1,
                            'tickers': 1,
                            'trades': 1,
                        },
                    },
                    'private': {
                        # for orders: spot 20/s, todo: perp 40/s
                        'get': {
                            'user': 7.5,
                            'orders': 7.5,
                            'orders/by-client-order-id': 7.5,
                            'orders/history': 7.5,
                            'orders/history/by-client-order-id': 7.5,
                            'orders/history_offset': 7.5,
                            'orders/{id}': 7.5,
                            'trades': 7.5,
                            'trades/history': 7.5,
                            'trades/time': 7.5,
                            'trigger-orders': 7.5,
                            'account/airdrops': 7.5,
                            'account/balance-updates': 7.5,
                            'account/balances': 7.5,
                            'account/balances/ll': 7.5,
                            'account/balances/history': 7.5,
                            'account/balances/commissions': 7.5,
                            'account/deposit/addresses': 7.5,
                            'account/deposits': 7.5,
                            'account/fees': 7.5,
                            'account/funding-rate-payments': 7.5,
                            'account/leverage': 7.5,
                            'account/lsp-assignments': 7.5,
                            'account/margin': 7.5,
                            'account/margin/all': 7.5,
                            'account/notifications': 7.5,
                            'account/position-updates': 7.5,
                            'account/positions': 7.5,
                            'account/realized-pnl': 7.5,
                            'account/rebates': 7.5,
                            'account/referral-links': 7.5,
                            'account/sessions': 7.5,
                            'account/settings': 7.5,
                            'account/settings/price-alert': 7.5,
                            'account/transfers': 7.5,
                            'account/unsubscribe': 7.5,
                            'account/watchlist': 7.5,
                            'account/withdrawal/addresses': 7.5,
                            'account/withdrawal/addresses/{id}': 7.5,
                            'account/withdrawals': 7.5,
                            'subaccounts': 7.5,
                            'airdrop': 7.5,
                            'airdrop/claim': 7.5,
                            'affiliate-dashboard/commission-earned': 7.5,
                            'affiliate-dashboard/min-arkm-last-30d': 7.5,
                            'affiliate-dashboard/points': 7.5,
                            'affiliate-dashboard/points-season-1': 7.5,
                            'affiliate-dashboard/points-season-2': 7.5,
                            'affiliate-dashboard/realized-pnl': 7.5,
                            'affiliate-dashboard/rebate-balance': 7.5,
                            'affiliate-dashboard/referral-count': 7.5,
                            'affiliate-dashboard/referrals-season-1': 7.5,
                            'affiliate-dashboard/referrals-season-2': 7.5,
                            'affiliate-dashboard/trading-volume-stats': 7.5,
                            'affiliate-dashboard/volume-season-1': 7.5,
                            'affiliate-dashboard/volume-season-2': 7.5,
                            'affiliate-dashboard/api-key': 7.5,
                            'competitions/opt-in-status': 7.5,
                            'rewards/info': 7.5,
                            'rewards/vouchers': 7.5,
                        },
                        'post': {
                            'orders/new': 7.5,
                            'trigger-orders/new': 7.5,
                            'orders/cancel': 7.5,
                            'trigger-orders/cancel': 7.5,
                            'orders/cancel/all': 7.5,
                            'trigger-orders/cancel/all': 7.5,
                            'orders/new/simple': 7.5,
                            'account/deposit/addresses/new': 7.5,
                            'account/leverage': 7.5,
                            'account/notifications/read': 7.5,
                            'account/referral-links': 7.5,
                            'account/sessions/delete': 7.5,
                            'account/sessions/terminate-all': 7.5,
                            'account/settings/update': 7.5,
                            'account/watchlist/add': 7.5,
                            'account/watchlist/remove': 7.5,
                            'account/withdraw': 7.5,
                            'account/withdrawal/addresses/confirm': 7.5,
                            'subaccounts': 7.5,
                            'subaccounts/transfer': 7.5,
                            'subaccounts/perp-transfer': 7.5,
                            'subaccounts/update-settings': 7.5,
                            'airdrop': 7.5,
                            'api-key/create': 7.5,
                            'authenticate': 7.5,
                            'competitions/opt-in': 7.5,
                            'rewards/vouchers/claim': 7.5,
                        },
                        'put': {
                            'account/referral-links/{id}/slug': 7.5,
                            'account/settings/price-alert': 7.5,
                            'account/withdrawal/addresses/{id}': 7.5,
                            'subaccounts': 7.5,
                            'api-key/update/{id}': 7.5,
                        },
                        'delete': {
                            'account/settings/price-alert': 7.5,
                            'account/withdrawal/addresses/{id}': 7.5,
                            'subaccounts/{subaccountId}': 7.5,
                            'api-key/{id}': 7.5,
                        },
                    },
                },
            },
            'options': {
                'networks': {
                    'ETH': 'ETH',
                    'ERC20': 'ETH',
                    'BTC': 'BTC',
                    'SOL': 'SOL',
                    'TON': 'TON',
                    'DOGE': 'DOGE',
                    'SUI': 'SUI',
                    'XRP': 'XRP',
                    'OP': 'OP',
                    'AVAXC': 'AVAX',
                    'ARBONE': 'ARB',
                },
                'networksById': {
                    'ETH': 'ERC20',
                    'ERC20': 'ERC20',
                },
                'requestExpiration': 5000,  # 5 seconds
                'timeframeDurations': {
                    '1m': 60000000,
                    '5m': 300000000,
                    '15m': 900000000,
                    '30m': 1800000000,
                    '1h': 3600000000,
                    '6h': 21600000000,
                    '1d': 86400000000,
                },
            },
            'features': {
                'default': {
                    'sandbox': False,
                    'createOrder': {
                        'marginMode': False,
                        'triggerPrice': True,
                        'triggerPriceType': {
                            'mark': True,
                            'index': True,
                            'last': True,
                        },
                        'triggerDirection': True,
                        'stopLossPrice': True,
                        'takeProfitPrice': True,
                        'attachedStopLossTakeProfit': None,
                        'timeInForce': {
                            'IOC': True,
                            'FOK': True,
                            'PO': True,
                            'GTD': False,
                        },
                        'hedged': False,
                        'selfTradePrevention': False,
                        'trailing': False,
                        'iceberg': False,
                        'leverage': False,
                        'marketBuyByCost': False,
                        'marketBuyRequiresPrice': False,
                    },
                    'createOrders': None,
                    'fetchMyTrades': {
                        'marginMode': False,
                        'limit': 100,
                        'daysBack': None,
                        'untilDays': 1,
                        'symbolRequired': False,
                    },
                    'fetchOrder': {
                        'marginMode': False,
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': False,
                    },
                    'fetchOpenOrders': {
                        'marginMode': True,
                        'limit': None,
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': False,
                    },
                    'fetchOrders': None,
                    'fetchClosedOrders': {
                        'marginMode': False,
                        'limit': 100,
                        'daysBack': None,
                        'daysBackCanceled': None,
                        'untilDays': None,
                        'trigger': False,
                        'trailing': False,
                        'symbolRequired': False,
                    },
                    'fetchOHLCV': {
                        'limit': 365,
                    },
                },
                'spot': {
                    'extends': 'default',
                },
                'swap': {
                    'linear': {
                        'extends': 'default',
                    },
                    'inverse': None,
                },
                'future': {
                    'linear': {
                        'extends': 'default',
                    },
                    'inverse': None,
                },
            },
            'precisionMode': TICK_SIZE,
            'exceptions': {
                'exact': {
                    # 1XXXX General Errors
                    # These errors can occur for a variety of reasons and may be returned by the API or Websocket on any endpoint.
                    '10000': OperationFailed,
                    '10001': BadRequest,
                    '10002': AuthenticationError,
                    '10003': BadSymbol,
                    '10004': ArgumentsRequired,
                    '10005': RateLimitExceeded,
                    '10006': PermissionDenied,
                    '10007': PermissionDenied,
                    '10008': RateLimitExceeded,
                    '10009': PermissionDenied,
                    '10010': PermissionDenied,
                    '10011': AuthenticationError,
                    '10012': PermissionDenied,
                    '10013': PermissionDenied,
                    '10014': AuthenticationError,
                    '10015': PermissionDenied,
                    '10016': PermissionDenied,
                    '10017': PermissionDenied,
                    '10018': AuthenticationError,
                    '10019': AuthenticationError,
                    '10020': PermissionDenied,
                    '10021': PermissionDenied,
                    '10022': ExchangeError,
                    '10023': BadRequest,
                    '10024': ExchangeError,
                    '10025': BadRequest,
                    #  #2XXXX General Websocket Errors
                    '20001': BadRequest,
                    '20002': ArgumentsRequired,
                    '20003': BadRequest,
                    '20004': ArgumentsRequired,
                    '20005': BadRequest,
                    #  #3XXXX Trading Errors
                    '30001': InvalidOrder,
                    '30002': InvalidOrder,
                    '30003': InvalidOrder,
                    '30004': InvalidOrder,
                    '30005': InvalidOrder,
                    '30006': InvalidOrder,
                    '30007': BadSymbol,
                    '30008': OperationRejected,
                    '30009': OperationRejected,
                    '30010': InsufficientFunds,
                    '30011': BadSymbol,
                    '30012': OperationRejected,
                    '30013': OperationRejected,
                    '30014': InvalidOrder,
                    '30015': OrderNotFound,
                    '30016': InvalidOrder,
                    '30017': InvalidOrder,
                    '30018': InvalidOrder,
                    '30019': OperationRejected,
                    '30020': InvalidOrder,
                    '30021': InvalidOrder,
                    '30022': InvalidOrder,
                    '30023': InvalidOrder,
                    '30024': InvalidOrder,
                    '30025': BadRequest,
                    '30026': PermissionDenied,
                    '30027': PermissionDenied,
                    '30028': OrderNotFound,
                    #  #4XXXX Funding Errors
                    '40001': OperationRejected,
                    '40002': BadRequest,
                    '40003': InvalidAddress,
                    '40004': OperationRejected,
                    '40005': BadRequest,
                    '40006': PermissionDenied,
                    '40007': OperationRejected,
                    '40008': OperationRejected,
                    '40009': OperationRejected,
                    '40010': BadRequest,
                    '40011': OperationRejected,
                    '40012': BadRequest,
                    '40013': BadRequest,
                    #  #9XXXX Other Errors
                    '90001': BadRequest,
                    '90002': BadRequest,
                    '90003': OperationRejected,
                    '90004': BadRequest,
                    '90005': BadRequest,
                    '90006': RateLimitExceeded,
                    '90007': AuthenticationError,
                    '90008': RateLimitExceeded,
                    '90009': PermissionDenied,
                    '90010': BadRequest,
                    '90011': RateLimitExceeded,
                },
                'broad': {
                    'less than min withdrawal ': OperationRejected,  # {"message":"amount 1 less than min withdrawal 5"}
                },
            },
        })

    async def fetch_currencies(self, params={}) -> Currencies:
        """
        fetches all available currencies on an exchange

        https://arkm.com/docs#get/public/assets

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: an associative dictionary of currencies
        """
        response = await self.v1PublicGetAssets(params)
        #
        #    [
        #        {
        #            "symbol": "USDT",
        #            "name": "Tether",
        #            "imageUrl": "https://static.arkhamintelligence.com/tokens/tether.png",
        #            "stablecoin": True,
        #            "featuredPair": "BTC_USDT",
        #            "chains": [
        #                {
        #                    "symbol": "ETH",
        #                    "assetSymbol": "ETH",
        #                    "name": "Ethereum",
        #                    "type": "1",
        #                    "confirmations": "6",
        #                    "blockTime": "12000000"
        #                }
        #            ],
        #            "status": "listed",
        #            "minDeposit": "5",
        #            "minWithdrawal": "5",
        #            "withdrawalFee": "2"
        #        },
        #        ...
        #
        result: dict = {}
        for i in range(0, len(response)):
            currency = response[i]
            id = self.safe_string(currency, 'symbol')
            code = self.safe_currency_code(id)
            networks: dict = {}
            chains = self.safe_list(currency, 'chains', [])
            for j in range(0, len(chains)):
                chain = chains[j]
                networkId = self.safe_string(chain, 'symbol')
                network = self.network_id_to_code(networkId)
                networks[network] = {
                    'info': chain,
                    'id': networkId,
                    'network': network,
                    'title': self.safe_string(chain, 'name'),
                    'active': None,
                    'deposit': None,
                    'withdraw': None,
                    'fee': None,
                    'precision': None,
                    'limits': {
                        'withdraw': {
                            'min': None,
                            'max': None,
                        },
                    },
                }
            result[code] = self.safe_currency_structure({
                'info': currency,
                'id': id,
                'code': code,
                'name': self.safe_string(currency, 'name'),
                'active': self.safe_string(currency, 'status') == 'listed',
                'deposit': None,
                'withdraw': None,
                'fee': self.safe_number(currency, 'withdrawalFee'),
                'precision': None,
                'limits': {
                    'amount': {
                        'min': None,
                        'max': None,
                    },
                    'withdraw': {
                        'min': self.safe_number(currency, 'minWithdrawal'),
                        'max': None,
                    },
                    'deposit': {
                        'min': self.safe_number(currency, 'minDeposit'),
                        'max': None,
                    },
                },
                'type': 'crypto',
                'networks': networks,
            })
        return result

    async def fetch_markets(self, params={}) -> List[Market]:
        """

        https://arkm.com/docs#get/public/pairs

        retrieves data on all markets for arkm
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: an array of objects representing market data
        """
        response = await self.v1PublicGetPairs(params)
        #
        #    [
        #        {
        #            "symbol": "BTC_USDT",
        #            "baseSymbol": "BTC",
        #            "baseImageUrl": "https://static.arkhamintelligence.com/tokens/bitcoin.png",
        #            "baseIsStablecoin": False,
        #            "baseName": "Bitcoin",
        #            "quoteSymbol": "USDT",
        #            "quoteImageUrl": "https://static.arkhamintelligence.com/tokens/tether.png",
        #            "quoteIsStablecoin": True,
        #            "quoteName": "Tether",
        #            "minTickPrice": "0.01",
        #            "minLotSize": "0.00001",
        #            "minSize": "0.00001",
        #            "maxSize": "9000",
        #            "minPrice": "0.01",
        #            "maxPrice": "1000000",
        #            "minNotional": "5",
        #            "maxPriceScalarUp": "1.8",
        #            "maxPriceScalarDown": "0.2",
        #            "pairType": "spot",  # atm, always 'spot' value
        #            "maxLeverage": "0",
        #            "status": "listed"
        #        },
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "baseSymbol": "BTC.P",
        #            "baseImageUrl": "https://static.arkhamintelligence.com/tokens/bitcoin.png",
        #            "baseIsStablecoin": False,
        #            "baseName": "Bitcoin Perpetual",
        #            "quoteSymbol": "USDT",
        #            "quoteImageUrl": "https://static.arkhamintelligence.com/tokens/tether.png",
        #            "quoteIsStablecoin": True,
        #            "quoteName": "Tether",
        #            "minTickPrice": "0.01",
        #            "minLotSize": "0.00001",
        #            "minSize": "0.00001",
        #            "maxSize": "9000",
        #            "minPrice": "0.01",
        #            "maxPrice": "1000000",
        #            "minNotional": "5",
        #            "maxPriceScalarUp": "1.5",
        #            "maxPriceScalarDown": "0.5",
        #            "pairType": "perpetual",
        #            "marginSchedule": "C",
        #            "maxLeverage": "25",
        #            "status": "listed"
        #        },
        #        ...
        #
        result = []
        for i in range(0, len(response)):
            market = response[i]
            id = self.safe_string(market, 'symbol')
            baseId = self.safe_string(market, 'baseSymbol')
            quoteId = self.safe_string(market, 'quoteSymbol')
            base = self.safe_currency_code(baseId)
            quote = self.safe_currency_code(quoteId)
            marketType: Str = None
            symbol: Str = None
            pairType = self.safe_string(market, 'pairType')
            isSpot = pairType == 'spot'
            isPerpetual = pairType == 'perpetual'
            settle = None
            settleId = None
            if isSpot:
                marketType = 'spot'
                symbol = base + '/' + quote
            elif isPerpetual:
                marketType = 'swap'
                base = base.replace('.P', '')
                settle = quote
                settleId = quoteId
                symbol = base + '/' + quote + ':' + settle
            result.append({
                'id': id,
                'symbol': symbol,
                'base': base,
                'quote': quote,
                'settle': settle,
                'baseId': baseId,
                'quoteId': quoteId,
                'settleId': settleId,
                'type': marketType,
                'spot': isSpot,
                'margin': None,
                'swap': isPerpetual,
                'future': False,
                'option': False,
                'active': self.safe_string(market, 'status') == 'listed',
                'contract': isPerpetual,
                'linear': True if isPerpetual else None,
                'inverse': False if isPerpetual else None,
                'contractSize': None if isSpot else 1,  # seems 1 per fetchTrades
                'expiry': None,
                'expiryDatetime': None,
                'strike': None,
                'optionType': None,
                'precision': {
                    'price': self.safe_number(market, 'minTickPrice'),
                    'amount': self.safe_number(market, 'minLotSize'),
                },
                'limits': {
                    'leverage': {
                        'min': None,
                        'max': None,
                    },
                    'amount': {
                        'min': self.safe_number(market, 'minSize'),
                        'max': self.safe_number(market, 'maxSize'),
                    },
                    'price': {
                        'min': self.safe_number(market, 'minPrice'),
                        'max': self.safe_number(market, 'maxPrice'),
                    },
                    'cost': {
                        'min': self.safe_number(market, 'minNotional'),
                        'max': None,
                    },
                },
                'created': None,
                'info': market,
            })
        return result

    async def fetch_time(self, params={}):
        """
        fetches the current integer timestamp in milliseconds from the exchange server

        https://arkm.com/docs#get/public/server-time

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns int: the current integer timestamp in milliseconds from the exchange server
        """
        response = await self.v1PublicGetServerTime(params)
        #
        #    {
        #        "serverTime": "1753465832770820"
        #    }
        #
        return self.safe_integer_product(response, 'serverTime', 0.001)

    async 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://arkm.com/docs#get/public/book

        :param str symbol: unified symbol of the market to fetch the order book for
        :param int [limit]: the number of order book entries to return, max 50
        :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
        """
        await self.load_markets()
        market = self.market(symbol)
        request: dict = {
            'symbol': market['id'],
        }
        if limit is not None:
            request['limit'] = limit
        response = await self.v1PublicGetBook(self.extend(request, params))
        #
        #    {
        #        "symbol": "BTC_USDT",
        #        "group": "0.01",
        #        "asks": [
        #            {
        #                "price": "122900.43",
        #                "size": "0.0243"
        #            },
        #            {
        #                "price": "121885.53",
        #                "size": "0.00116"
        #            },
        #            ...
        #        ],
        #        "bids": [
        #            {
        #                "price": "20400",
        #                "size": "0.00316"
        #            },
        #            {
        #                "price": "30000",
        #                "size": "0.00116"
        #            },
        #            ...
        #        ],
        #        "lastTime": "1753419275604353"
        #    }
        #
        timestamp = self.safe_integer_product(response, 'lastTime', 0.001)
        marketId = self.safe_string(response, 'symbol')
        return self.parse_order_book(response, self.safe_symbol(marketId, market), timestamp, 'bids', 'asks', 'price', 'size')

    async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
        """
        fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market

        https://arkm.com/docs#get/public/candles

        :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 exchange API endpoint
        :param int [params.until]: timestamp in ms for the ending date filter, default is the current time
        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
        :returns int[][]: A list of candles ordered, open, high, low, close, volume
        """
        maxLimit = 365
        await self.load_markets()
        paginate = False
        paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate', False)
        if paginate:
            return await self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimit)
        market = self.market(symbol)
        request: dict = {
            'symbol': market['id'],
            'duration': self.safe_string(self.timeframes, timeframe, timeframe),
        }
        durationMs = self.parse_timeframe(timeframe) * 1000
        until = self.safe_integer(params, 'until')
        params = self.omit(params, ['until'])
        selectedLimit = min(limit, maxLimit) if (limit is not None) else maxLimit
        if since is not None:
            request['start'] = since
            request['end'] = self.sum(since, selectedLimit * durationMs)
        else:
            now = self.milliseconds()
            request['end'] = until if (until is not None) else now
            request['start'] = request['end'] - selectedLimit * durationMs
        # exchange needs microseconds
        request['start'] = request['start'] * 1000
        request['end'] = request['end'] * 1000
        response = await self.v1PublicGetCandles(self.extend(request, params))
        #
        #    [
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "time": "1753464720000000",
        #            "duration": "60000000",
        #            "open": "116051.35",
        #            "high": "116060.27",
        #            "low": "116051.35",
        #            "close": "116060.27",
        #            "volume": "0.0257",
        #            "quoteVolume": "2982.6724054"
        #        },
        #        ...
        #    ]
        #
        return self.parse_ohlcvs(response, market, timeframe, since, limit)

    def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
        #
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "time": "1753464720000000",
        #            "duration": "60000000",
        #            "open": "116051.35",
        #            "high": "116060.27",
        #            "low": "116051.35",
        #            "close": "116060.27",
        #            "volume": "0.0257",
        #            "quoteVolume": "2982.6724054"
        #        }
        #
        return [
            self.safe_integer_product(ohlcv, 'time', 0.001),
            self.safe_number(ohlcv, 'open'),
            self.safe_number(ohlcv, 'high'),
            self.safe_number(ohlcv, 'low'),
            self.safe_number(ohlcv, 'close'),
            self.safe_number(ohlcv, 'volume'),
        ]

    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
        response = await self.v1PublicGetTickers(params)
        #
        #    [
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "baseSymbol": "BTC.P",
        #            "quoteSymbol": "USDT",
        #            "indexCurrency": "USDT",
        #            "price": "118806.89",
        #            "price24hAgo": "118212.29",
        #            "high24h": "119468.05",
        #            "low24h": "117104.44",
        #            "volume24h": "180.99438",
        #            "quoteVolume24h": "21430157.5928827",
        #            "markPrice": "118814.71",
        #            "indexPrice": "118804.222610343",
        #            "fundingRate": "0.000007",
        #            "nextFundingRate": "0.000006",
        #            "nextFundingTime": "1753390800000000",
        #            "productType": "perpetual",
        #            "openInterest": "2.55847",
        #            "usdVolume24h": "21430157.5928827",
        #            "openInterestUSD": "303963.8638583"
        #        },
        #        ...
        #
        return self.parse_tickers(response, symbols)

    async 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
        :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>`
        """
        await self.load_markets()
        market = self.market(symbol)
        request: dict = {
            'symbol': market['id'],
        }
        response = await self.v1PublicGetTicker(self.extend(request, params))
        #
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "baseSymbol": "BTC.P",
        #            "quoteSymbol": "USDT",
        #            "indexCurrency": "USDT",
        #            "price": "118806.89",
        #            "price24hAgo": "118212.29",
        #            "high24h": "119468.05",
        #            "low24h": "117104.44",
        #            "volume24h": "180.99438",
        #            "quoteVolume24h": "21430157.5928827",
        #            "markPrice": "118814.71",
        #            "indexPrice": "118804.222610343",
        #            "fundingRate": "0.000007",
        #            "nextFundingRate": "0.000006",
        #            "nextFundingTime": "1753390800000000",
        #            "productType": "perpetual",
        #            "openInterest": "2.55847",
        #            "usdVolume24h": "21430157.5928827",
        #            "openInterestUSD": "303963.8638583"
        #        }
        #
        return self.parse_ticker(response, market)

    def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
        marketId = self.safe_string(ticker, 'symbol')
        market = self.safe_market(marketId, market)
        return self.safe_ticker({
            'info': ticker,
            'symbol': self.safe_symbol(marketId, market),
            'high': self.safe_number(ticker, 'high24h'),
            'low': self.safe_number(ticker, 'low24h'),
            'bid': self.safe_number(ticker, 'bid'),
            'last': self.safe_number(ticker, 'price'),
            'open': self.safe_number(ticker, 'price24hAgo'),
            'change': self.safe_number(ticker, 'priceChange'),
            'percentage': self.safe_number(ticker, 'priceChangePercent'),
            'baseVolume': self.safe_number(ticker, 'volume24h'),
            'quoteVolume': self.safe_number(ticker, 'usdVolume24h'),
            'markPrice': self.safe_number(ticker, 'markPrice'),
            'indexPrice': self.safe_number(ticker, 'indexPrice'),
            'vwap': None,
            'average': None,
            'previousClose': None,
            'askVolume': None,
            'bidVolume': None,
        })

    async def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
        """
        get the list of most recent trades for a particular symbol

        https://arkm.com/docs#get/public/trades

        :param str symbol: unified symbol of the market to fetch trades for
        :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 exchange API endpoint
        :param str [params.loc]: crypto location, default: us
        :param str [params.method]: method, default: marketPublicGetV1beta3CryptoLocTrades
        :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/?id=public-trades>`
        """
        await self.load_markets()
        market = self.market(symbol)
        marketId = market['id']
        request: dict = {
            'symbol': marketId,
        }
        if limit is not None:
            request['limit'] = limit
        response = await self.v1PublicGetTrades(self.extend(request, params))
        #
        #    [
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "revisionId": "1130514101",
        #            "size": "0.01668",
        #            "price": "116309.57",
        #            "takerSide": "sell",
        #            "time": "1753439710374047"
        #        },
        #        ...
        #    ]
        #
        return self.parse_trades(response, market, since, limit)

    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
        #
        # fetchTrades
        #
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "revisionId": "1130514101",
        #            "size": "0.01668",
        #            "price": "116309.57",
        #            "takerSide": "sell",
        #            "time": "1753439710374047"
        #        }
        #
        # fetchMyTrades
        #
        #        {
        #            "symbol": "SOL_USDT",
        #            "revisionId": "891839406",
        #            "size": "0.042",
        #            "price": "185.06",
        #            "takerSide": "sell",
        #            "time": "1753773952039342",
        #            "orderId": "3717304929194",
        #            "userSide": "sell",
        #            "quoteFee": "0.00777252",
        #            "arkmFee": "0",
        #            "clientOrderId": ""
        #        }
        #
        marketId = self.safe_string(trade, 'symbol')
        market = self.safe_market(marketId, market)
        timestamp = self.safe_integer_product(trade, 'time', 0.001)
        quoteFee = self.safe_number(trade, 'quoteFee')
        arkmFee = self.safe_number(trade, 'arkmFee')
        fee = None
        if quoteFee is not None:
            fee = {
                'cost': quoteFee,
                'currency': market['quote'],
            }
        elif arkmFee is not None:
            fee = {
                'cost': arkmFee,
                'currency': 'ARKM',
            }
        return self.safe_trade({
            'info': trade,
            'id': self.safe_string(trade, 'revisionId'),
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'symbol': market['symbol'],
            'type': None,
            'side': self.safe_string_2(trade, 'userSide', 'takerSide'),  # priority to userSide
            'takerOrMaker': None,
            'price': self.safe_string(trade, 'price'),
            'amount': self.safe_string(trade, 'size'),
            'cost': None,
            'fee': fee,
            'order': self.safe_string(trade, 'orderId'),
        }, market)

    async def fetch_order(self, id: str, symbol: Str = None, params={}):
        """
        fetches information on an order made by the user

        https://arkm.com/docs#get/orders/by-client-order-id

        :param str id: the order id
        :param str symbol: unified symbol of the market the order was made in
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param str [params.clientOrderId]: a unique id for the order
        :returns dict: An `order structure <https://docs.ccxt.com/?id=order-structure>`
        """
        request: dict = {
            'id': int(id),
        }
        response = await self.v1PrivateGetOrdersId(self.extend(request, params))
        #
        #    {
        #        "orderId": "3690478767430",
        #        "userId": "2959123",
        #        "subaccountId": "0",
        #        "symbol": "SOL_USDT",
        #        "time": "1753696843913970",
        #        "side": "sell",
        #        "type": "limitGtc",
        #        "size": "0.066",
        #        "price": "293.2",
        #        "postOnly": False,
        #        "reduceOnly": False,
        #        "executedSize": "0",
        #        "status": "booked",
        #        "avgPrice": "0",
        #        "executedNotional": "0",
        #        "creditFeePaid": "0",
        #        "marginBonusFeePaid": "0",
        #        "quoteFeePaid": "0",
        #        "arkmFeePaid": "0",
        #        "revisionId": "887956326",
        #        "lastTime": "1753696843914830",
        #        "clientOrderId": "",
        #        "lastSize": "0",
        #        "lastPrice": "0",
        #        "lastCreditFee": "0",
        #        "lastMarginBonusFee": "0",
        #        "lastQuoteFee": "0",
        #        "lastArkmFee": "0"
        #    }
        #
        return self.parse_order(response)

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

        https://arkm.com/docs#get/orders/history

        :param str symbol: unified market symbol of the market orders were made in
        :param int [since]: the earliest time in ms to fetch orders for
        :param int [limit]: the maximum number of order structures to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param int [params.until]: the latest time in ms to fetch orders for
        :returns Order[]: a list of `order structures <https://docs.ccxt.com/?id=order-structure>`
        """
        await self.load_markets()
        request: dict = {}
        market = None
        if symbol is not None:
            market = self.market(symbol)
            request['symbol'] = market['id']
        if limit is not None:
            request['limit'] = limit  # note, API does not work for self param
        response = await self.v1PrivateGetOrdersHistory(self.extend(request, params))
        #
        #     [
        #        {
        #            "orderId": "3690478767430",
        #            "userId": "2959123",
        #            "subaccountId": "0",
        #            "symbol": "SOL_USDT",
        #            "time": "1753696843913970",
        #            "side": "sell",
        #            "type": "limitGtc",
        #            "size": "0.066",
        #            "price": "293.2",
        #            "postOnly": False,
        #            "reduceOnly": False,
        #            "executedSize": "0",
        #            "status": "closed",
        #            "avgPrice": "0",
        #            "executedNotional": "0",
        #            "creditFeePaid": "0",
        #            "marginBonusFeePaid": "0",
        #            "quoteFeePaid": "0",
        #            "arkmFeePaid": "0",
        #            "revisionId": "888084076",
        #            "lastTime": "1753701350088305",
        #            "clientOrderId": "",
        #            "lastSize": "0",
        #            "lastPrice": "0",
        #            "lastCreditFee": "0",
        #            "lastMarginBonusFee": "0",
        #            "lastQuoteFee": "0",
        #            "lastArkmFee": "0"
        #        }
        #    ]
        #
        return self.parse_orders(response, market, since, limit)

    async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
        """
        fetch all unfilled currently open orders

        https://arkm.com/docs#get/orders

        :param str symbol: unified market symbol of the market orders were made in
        :param int [since]: the earliest time in ms to fetch orders for
        :param int [limit]: the maximum number of order structures to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param int [params.until]: the latest time in ms to fetch orders for
        :returns Order[]: a list of `order structures <https://docs.ccxt.com/?id=order-structure>`
        """
        await self.load_markets()
        market = None
        if symbol is not None:
            market = self.market(symbol)
        isTriggerOrder = self.safe_bool(params, 'trigger')
        params = self.omit(params, 'trigger')
        response = None
        if isTriggerOrder:
            response = await self.v1PrivateGetTriggerOrders(self.extend({}, params))
            #
            #    [
            #        {
            #            "subaccountId": "0",
            #            "symbol": "SOL_USDT",
            #            "side": "sell",
            #            "type": "market",
            #            "size": "0.045",
            #            "price": "99.9",
            #            "postOnly": False,
            #            "reduceOnly": False,
            #            "time": "1753768103780063",
            #            "triggerOrderId": "3715847222127",
            #            "triggerType": "stopLoss",
            #            "triggerPriceType": "last",
            #            "triggerPrice": "111",
            #            "clientOrderId": "",
            #            "status": "staged"
            #        },
            #    ]
            #
        else:
            response = await self.v1PrivateGetOrders(self.extend({}, params))
            #
            # [
            #    {
            #        "orderId": "3690478767430",
            #        "userId": "2959123",
            #        "subaccountId": "0",
            #        "symbol": "SOL_USDT",
            #        "time": "1753696843913970",
            #        "side": "sell",
            #        "type": "limitGtc",
            #        "size": "0.066",
            #        "price": "293.2",
            #        "postOnly": False,
            #        "reduceOnly": False,
            #        "executedSize": "0",
            #        "status": "booked",
            #        "avgPrice": "0",
            #        "executedNotional": "0",
            #        "creditFeePaid": "0",
            #        "marginBonusFeePaid": "0",
            #        "quoteFeePaid": "0",
            #        "arkmFeePaid": "0",
            #        "revisionId": "887956326",
            #        "lastTime": "1753696843914830",
            #        "clientOrderId": "",
            #        "lastSize": "0",
            #        "lastPrice": "0",
            #        "lastCreditFee": "0",
            #        "lastMarginBonusFee": "0",
            #        "lastQuoteFee": "0",
            #        "lastArkmFee": "0"
            #    }
            # ]
            #
        return self.parse_orders(response, market, since, limit)

    async def cancel_order(self, id: str, symbol: Str = None, params={}):
        """
        cancels an open order

        https://arkm.com/docs#post/orders/cancel

        :param str id: order id
        :param str symbol: unified symbol of the market the order was made in
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: An `order structure <https://docs.ccxt.com/?id=order-structure>`
        """
        isTriggerOrder = self.safe_bool(params, 'trigger')
        params = self.omit(params, 'trigger')
        response = None
        request: dict = {}
        clientOrderId = self.safe_integer(params, 'clientOrderId')
        if clientOrderId is not None:
            params = self.omit(params, 'clientOrderId')
            request['clientOrderId'] = clientOrderId
        else:
            if isTriggerOrder:
                request['triggerOrderId'] = int(id)
            else:
                request['orderId'] = int(id)
        if isTriggerOrder:
            if symbol is None:
                raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument for trigger orders')
            market = self.market(symbol)
            request['symbol'] = market['id']
            response = await self.v1PrivatePostTriggerOrdersCancel(self.extend(request, params))
        else:
            response = await self.v1PrivatePostOrdersCancel(self.extend(request, params))
        #
        # {"orderId":3691703758327}
        #
        return self.parse_order(response)

    async def cancel_all_orders(self, symbol: Str = None, params={}):
        """
        cancel all open orders in a market

        https://arkm.com/docs#post/orders/cancel/all

        :param str symbol: cancel alls open orders
        :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>`
        """
        if symbol is not None:
            raise BadRequest(self.id + ' cancelAllOrders() does not support a symbol argument, use cancelOrder() or fetchOpenOrders() instead')
        isTriggerOrder = self.safe_bool(params, 'trigger')
        params = self.omit(params, 'trigger')
        response = None
        if isTriggerOrder:
            response = await self.v1PrivatePostTriggerOrdersCancelAll(params)
        else:
            response = await self.v1PrivatePostOrdersCancelAll(params)
        #
        # []  returns an empty array, even when successfully cancels orders
        #
        return self.parse_orders(response)

    async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
        """
        create a trade order on the exchange

        https://arkm.com/docs#post/orders/new

        :param str symbol: unified CCXT market symbol
        :param str type: "limit" or "market"
        :param str side: "buy" or "sell"
        :param float amount: the amount of currency to trade
        :param float [price]: the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param str [params.timeInForce]: "GTC", "IOC", "FOK", or "PO"
        :param float [params.triggerPrice]: price for a trigger(conditional) order
        :param float [params.stopLossPrice]: price for a stoploss order
        :param float [params.takeProfitPrice]: price for a takeprofit order
        :param str [params.triggerDirection]: the direction for trigger orders, 'ascending' or 'descending'
        :param str [params.triggerPriceType]: mark, index or last
        :param bool [params.postOnly]: True or False whether the order is post-only
        :param bool [params.reduceOnly]: True or False whether the order is reduce-only
        :returns: `An order structure <https://docs.ccxt.com/?id=order-structure>`
        """
        await self.load_markets()
        market = self.market(symbol)
        isTriggerOrder = self.safe_number_n(params, ['triggerPrice', 'stopLossPrice', 'takeProfitPrice']) is not None
        request = self.create_order_request(symbol, type, side, amount, price, params)
        response = None
        if isTriggerOrder:
            response = await self.v1PrivatePostTriggerOrdersNew(request)
            #
            #    {
            #        "triggerOrderId": "3716436645573",
            #        "symbol": "SOL_USDT_PERP",
            #        "side": "buy",
            #        "type": "limitGtc",
            #        "size": "0.05",
            #        "price": "150"
            #    }
            #
        else:
            response = await self.v1PrivatePostOrdersNew(request)
            #
            #    {
            #        "orderId": "3694872060678",
            #        "clientOrderId": "test123",
            #        "symbol": "SOL_USDT",
            #        "subaccountId": "0",
            #        "side": "buy",
            #        "type": "limitGtc",
            #        "size": "0.05",
            #        "price": "170",
            #        "time": "1753710501474043"
            #    }
            #
        return self.parse_order(response, market)

    def create_order_request(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
        market = self.market(symbol)
        symbol = market['symbol']
        request: dict = {
            'symbol': market['id'],
            'side': side,
            'size': self.amount_to_precision(symbol, amount),
        }
        isBuy = (side == 'buy')
        stopLossPrice = self.safe_number(params, 'stopLossPrice')
        takeProfitPrice = self.safe_number(params, 'takeProfitPrice')
        triggerPriceAny = self.safe_string_n(params, ['triggerPrice', 'stopLossPrice', 'takeProfitPrice'])
        if triggerPriceAny is not None:
            request['triggerPrice'] = self.price_to_precision(symbol, triggerPriceAny)
            if stopLossPrice is not None:
                request['triggerType'] = 'stopLoss' if isBuy else 'takeProfit'
            elif takeProfitPrice is not None:
                request['triggerType'] = 'takeProfit' if isBuy else 'stopLoss'
            else:
                triggerDirection = self.safe_string(params, 'triggerDirection')
                if triggerDirection is None:
                    raise ArgumentsRequired(self.id + ' createOrder() requires a triggerDirection parameter when triggerPrice is specified, must be "ascending" or "descending"')
                if triggerDirection is not None:
                    if triggerDirection == 'ascending':
                        request['triggerType'] = 'stopLoss' if isBuy else 'takeProfit'
                    elif triggerDirection == 'descending':
                        request['triggerType'] = 'takeProfit' if isBuy else 'stopLoss'
            # mandatory triggerPriceType
            if self.safe_string(params, 'triggerPriceType') is None:
                request['triggerPriceType'] = 'last'  # default
        isMarketOrder = (type == 'market')
        isLimitOrder = (type == 'limit')
        isLimitExchangeSpecific = self.in_array(type, ['limitGtc', 'limitIoc', 'limitFok'])
        postOnly = self.is_post_only(isMarketOrder, False, params)
        timeInForce = self.safe_string(params, 'timeInForce')
        params = self.omit(params, ['postOnly', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'triggerDirection'])
        if postOnly:
            request['postOnly'] = True
        if isLimitOrder or isLimitExchangeSpecific:
            request['price'] = self.price_to_precision(symbol, price)
            #
            if timeInForce == 'IOC':
                request['type'] = 'limitIoc'
            elif timeInForce == 'FOK':
                request['type'] = 'limitFok'
            else:
                request['type'] = 'limitGtc'
        elif isMarketOrder:
            request['type'] = 'market'
        # we don't need to manually handle `reduceOnly`, `clientOrderId`, `triggerPriceType` here-specific keyname & values matches
        return self.extend(request, params)

    def parse_order(self, order: dict, market: Market = None) -> Order:
        #
        # createOrder
        #
        #    {
        #        "orderId": "3694872060678",
        #        "clientOrderId": "test123",
        #        "symbol": "SOL_USDT",
        #        "subaccountId": "0",
        #        "side": "buy",
        #        "type": "limitGtc",
        #        "size": "0.05",
        #        "price": "170",
        #        "time": "1753710501474043"
        #    }
        #
        # fetchOrder, fetchOpenOrders, fetchClosedOrders
        #
        #    {
        #        "orderId": "3690478767430",
        #        "userId": "2959123",
        #        "subaccountId": "0",
        #        "symbol": "SOL_USDT",
        #        "time": "1753696843913970",
        #        "side": "sell",
        #        "type": "limitGtc",
        #        "size": "0.066",
        #        "price": "293.2",
        #        "postOnly": False,
        #        "reduceOnly": False,
        #        "executedSize": "0",
        #        "status": "booked",
        #        "avgPrice": "0",
        #        "executedNotional": "0",
        #        "creditFeePaid": "0",
        #        "marginBonusFeePaid": "0",
        #        "quoteFeePaid": "0",
        #        "arkmFeePaid": "0",
        #        "revisionId": "887956326",
        #        "lastTime": "1753696843914830",
        #        "clientOrderId": "",
        #        "lastSize": "0",
        #        "lastPrice": "0",
        #        "lastCreditFee": "0",
        #        "lastMarginBonusFee": "0",
        #        "lastQuoteFee": "0",
        #        "lastArkmFee": "0"
        #    }
        #
        # trigger-orders: createOrder
        #
        #    {
        #        "triggerOrderId": "3716436645573",
        #        "symbol": "SOL_USDT_PERP",
        #        "side": "buy",
        #        "type": "limitGtc",
        #        "size": "0.05",
        #        "price": "150"
        #    }
        #
        # trigger-orders: fetchOpenOrders
        #
        #    {
        #            "subaccountId": "0",
        #            "symbol": "SOL_USDT",
        #            "side": "sell",
        #            "type": "market",
        #            "size": "0.045",
        #            "price": "99.9",
        #            "postOnly": False,
        #            "reduceOnly": False,
        #            "time": "1753768103780063",
        #            "triggerOrderId": "3715847222127",
        #            "triggerType": "stopLoss",
        #            "triggerPriceType": "last",
        #            "triggerPrice": "111",
        #            "clientOrderId": "",
        #            "status": "staged"
        #    }
        #
        marketId = self.safe_string(order, 'symbol')
        market = self.safe_market(marketId, market)
        isPostOnly = self.safe_bool(order, 'postOnly')
        typeRaw = self.safe_string(order, 'type')
        orderType = 'limit' if isPostOnly else self.parse_order_type(typeRaw)
        timeInForce = 'PO' if isPostOnly else self.parse_time_in_force(typeRaw)
        quoteFeePaid = self.safe_string(order, 'quoteFeePaid')
        arkmFeePaid = self.safe_string(order, 'arkmFeePaid')
        fees = []
        if quoteFeePaid is not None:
            fees.append({
                'cost': quoteFeePaid,
                'currency': self.safe_string(market, 'quote'),
            })
        if arkmFeePaid is not None:
            fees.append({
                'cost': arkmFeePaid,
                'currency': 'ARKM',
            })
        timestamp = self.safe_integer_product(order, 'time', 0.001)
        return self.safe_order({
            'id': self.safe_string_2(order, 'orderId', 'triggerOrderId'),
            'clientOrderId': self.safe_string(order, 'clientOrderId'),
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'lastTradeTimeStamp': None,
            'lastUpdateTimestamp': self.safe_integer_product(order, 'lastTime', 0.001),
            'status': self.parse_order_status(self.safe_string(order, 'status')),
            'symbol': market['symbol'],
            'type': orderType,
            'timeInForce': timeInForce,
            'postOnly': None,
            'side': self.safe_string(order, 'side'),
            'price': self.safe_number(order, 'price'),
            'triggerPrice': None,
            'cost': self.safe_number(order, 'executedNotional'),
            'average': self.safe_number_omit_zero(order, 'avgPrice'),
            'amount': self.safe_number(order, 'size'),
            'filled': self.safe_number(order, ''),
            'remaining': None,
            'trades': None,
            'fees': fees,
            'reduceOnly': self.safe_bool(order, 'reduceOnly'),
            'info': order,
        }, market)

    def parse_order_type(self, type: Str) -> Str:
        types: dict = {
            'limitGtc': 'limit',
            'limitIoc': 'limit',
            'limitFok': 'limit',
            'market': 'market',
        }
        return self.safe_string_upper(types, type, type)

    def parse_time_in_force(self, type: Str) -> Str:
        types: dict = {
            'limitGtc': 'GTC',
            'limitIoc': 'IOC',
            'limitFok': 'FOK',
            'market': 'IOC',
        }
        return self.safe_string_upper(types, type, type)

    def parse_order_status(self, status: Str):
        statuses: dict = {
            'new': 'pending',
            'staged': 'open',
            'booked': 'open',
            'taker': 'closed',
            'maker': 'closed',
            'cancelled': 'canceled',
            'closed': 'closed',
        }
        return self.safe_string(statuses, status, status)

    async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
        """
        fetch all trades made by the user

        https://arkm.com/docs#get/trades/time

        :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 trade structures to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param int [params.until]: the latest time in ms to fetch trades for
        :param str [params.page_token]: page_token - used for paging
        :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/?id=trade-structure>`
        """
        await self.load_markets()
        request: dict = {}
        if limit is not None:
            request['limit'] = limit
        # exchange needs to obtain some `from & to` values, otherwise it does not return any result
        defaultRange = 24 * 60 * 60 * 1000  # default to last 24 hours
        if since is not None:
            request['from'] = since * 1000  # convert ms to microseconds
        else:
            request['from'] = (self.milliseconds() - defaultRange) * 1000  # default to last 24 hours
        until = self.safe_integer(params, 'until')
        if until is not None:
            params = self.omit(params, 'until')
            request['to'] = until * 1000  # convert ms to microseconds
        else:
            request['to'] = self.sum(request['from'], defaultRange * 1000)
        request, params = self.handle_until_option('until', request, params)
        response = await self.v1PrivateGetTradesTime(self.extend(request, params))
        #
        #    [
        #        {
        #            "symbol": "SOL_USDT",
        #            "revisionId": "891839406",
        #            "size": "0.042",
        #            "price": "185.06",
        #            "takerSide": "sell",
        #            "time": "1753773952039342",
        #            "orderId": "3717304929194",
        #            "userSide": "sell",
        #            "quoteFee": "0.00777252",
        #            "arkmFee": "0",
        #            "clientOrderId": ""
        #        },
        #        ...
        #
        return self.parse_trades(response, None, since, limit)

    async def fetch_accounts(self, params={}) -> List[Account]:
        """
        fetch all the accounts associated with a profile

        https://arkm.com/docs#get/user

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a dictionary of `account structures <https://docs.ccxt.com/?id=account-structure>` indexed by the account type
        """
        await self.load_markets()
        request: dict = {}
        accountId = None
        accountId, params = self.handle_option_and_params(params, 'fetchAccounts', 'accountId')
        if accountId is not None:
            request['subAccountId'] = accountId
        response = await self.v1PrivateGetUser(self.extend(request, params))
        #
        #    {
        #        "id": "2959123",
        #        "email": "xyz@gmail.com",
        #        "username": "t.123",
        #        "requireMFA": True,
        #        "kycVerifiedAt": "1753434515850673",
        #        "pmm": False,
        #        "dmm": False,
        #        "becameVipAt": "0",
        #        "subaccounts": [
        #            {
        #                "id": "0",
        #                "name": "Primary",
        #                "pinned": True,
        #                "isLsp": False,
        #                "futuresEnabled": True,
        #                "payFeesInArkm": False,
        #                "lspSettings": []
        #            }
        #        ],
        #        "settings": {
        #            "autogenDepositAddresses": False,
        #            "hideBalances": False,
        #            "confirmBeforePlaceOrder": False,
        #            "tickerTapeScroll": True,
        #            "updatesFlash": True,
        #            "notifyOrderFills": False,
        #            "notifyAnnouncements": False,
        #            "notifyMarginUsage": False,
        #            "marginUsageThreshold": "0.5",
        #            "notifyWithdrawals": True,
        #            "notifyDeposits": True,
        #            "notifySendEmail": True,
        #            "notifyRebates": True,
        #            "notifyCommissions": True,
        #            "allowSequenceEmails": True,
        #            "language": "en"
        #        },
        #        "airdropKycAt": null
        #    }
        #
        subAccounts = self.safe_list(response, 'subaccounts', [])
        return self.parse_accounts(subAccounts, params)

    def parse_account(self, account):
        #
        #            {
        #                "id": "0",
        #                "name": "Primary",
        #                "pinned": True,
        #                "isLsp": False,
        #                "futuresEnabled": True,
        #                "payFeesInArkm": False,
        #                "lspSettings": []
        #            }
        #
        return {
            'id': self.safe_string(account, 'id'),
            'type': None,
            'code': None,
            'info': account,
        }

    async def fetch_balance(self, params={}) -> Balances:
        """
        query for account info

        https://arkm.com/docs#get/account/balances

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `balance structure <https://docs.ccxt.com/?id=balance-structure>`
        """
        await self.load_markets()
        response = await self.v1PrivateGetAccountBalances(params)
        #
        #    [
        #        {
        #            "subaccountId": "0",
        #            "symbol": "USDT",
        #            "balance": "19.66494694",
        #            "free": "19.66494694",
        #            "priceUSDT": "1",
        #            "balanceUSDT": "19.66494694",
        #            "freeUSDT": "19.66494694",
        #            "lastUpdateReason": "orderFill",
        #            "lastUpdateTime": "1753773952039342",
        #            "lastUpdateId": "248507437",
        #            "lastUpdateAmount": "7.77252"
        #        },
        #        {
        #            "subaccountId": "0",
        #            "symbol": "SOL",
        #            "balance": "0",
        #            "free": "0",
        #            "priceUSDT": "186.025584673",
        #            "balanceUSDT": "0",
        #            "freeUSDT": "0",
        #            "lastUpdateReason": "orderFill",
        #            "lastUpdateTime": "1753773952039342",
        #            "lastUpdateId": "248507435",
        #            "lastUpdateAmount": "-0.042"
        #        }
        #    ]
        #
        return self.parse_balance(response)

    def parse_balance(self, response) -> Balances:
        timestamp = self.safe_integer_product(response, 'lastUpdateTime', 0.001)
        result: dict = {
            'info': response,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
        }
        for i in range(0, len(response)):
            balance = response[i]
            symbol = self.safe_string(balance, 'symbol')
            code = self.safe_currency_code(symbol)
            account = self.account()
            account['total'] = self.safe_string(balance, 'balance')
            account['free'] = self.safe_string(balance, 'free')
            result[code] = account
        return self.safe_balance(result)

    async def create_deposit_address(self, code: str, params={}) -> DepositAddress:
        """
        create a currency deposit address

        https://arkm.com/docs#post/account/deposit/addresses/new

        :param str code: unified currency code of the currency for the deposit address
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: an `address structure <https://docs.ccxt.com/?id=address-structure>`
        """
        await self.load_markets()
        networkCode = None
        networkCode, params = self.handle_network_code_and_params(params)
        if networkCode is None:
            raise ArgumentsRequired(self.id + ' createDepositAddress() requires a "network" param')
        request: dict = {
            'chain': networkCode,
        }
        response = await self.v1PrivatePostAccountDepositAddressesNew(self.extend(request, params))
        #
        #    {
        #        "addresses": "12NauJ26TUT9aYkpId7YdePJJDRMGbAsEMVoTVUvBErV"
        #    }
        #
        address = self.safe_string(response, 'addresses')
        return self.parse_deposit_address(address, self.currency(code))

    async def fetch_deposit_addresses_by_network(self, code: str, params={}) -> List[DepositAddress]:
        """
        fetch the deposit addresses for a currency associated with self account

        https://arkm.com/docs#get/account/deposit/addresses

        :param str code: unified currency code
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a dictionary `address structures <https://docs.ccxt.com/?id=address-structure>`, indexed by the network
        """
        await self.load_markets()
        networkCode = None
        networkCode, params = self.handle_network_code_and_params(params)
        if networkCode is None:
            raise ArgumentsRequired(self.id + ' fetchDepositAddressesByNetwork() requires a "network" param')
        request: dict = {
            'chain': self.network_code_to_id(networkCode),
        }
        response = await self.v1PrivateGetAccountDepositAddresses(self.extend(request, params))
        #
        #    {
        #        "addresses": [
        #            "12NauJ26TUT9aYkpId7YdePJJDRMGbAsEMVoTVUvBErV"
        #        ]
        #    }
        #
        data = self.safe_list(response, 'addresses')
        networkCodeUnified = networkCode  # java req
        parsed = self.parse_deposit_addresses(data, None, False, {'network': networkCodeUnified})
        return self.index_by(parsed, 'network')

    def parse_deposit_address(self, entry, currency: Currency = None) -> DepositAddress:
        #
        #     "12NauJ26TUT9aYkpId7YdePJJDRMGbAsEMVoTVUvBErV"
        #
        return {
            'info': entry,
            'currency': self.safe_string(currency, 'code'),
            'network': None,
            'address': entry,
            'tag': None,
        }

    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
        """
        fetch the deposit address for a currency associated with self account

        https://arkm.com/docs#get/account/deposit/addresses

        :param str code: unified currency code
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: an `address structure <https://docs.ccxt.com/?id=address-structure>`
        """
        await self.load_markets()
        currency = self.currency(code)
        networkCodeAndParams = self.handle_network_code_and_params(params)
        networkCode = networkCodeAndParams[0]
        indexedAddresses = await self.fetch_deposit_addresses_by_network(code, params)
        selectedNetworkCode = self.select_network_code_from_unified_networks(currency['code'], networkCode, indexedAddresses)
        address = self.safe_dict(indexedAddresses, selectedNetworkCode)
        if address is None:
            raise InvalidAddress(self.id + ' fetchDepositAddress() could not find a deposit address for ' + code)
        return address

    async def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
        """
        fetch all deposits made to an account

        https://arkm.com/docs#get/account/deposits

        :param str code: unified currency code
        :param int [since]: the earliest time in ms to fetch deposits for
        :param int [limit]: the maximum number of deposits structures to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/?id=transaction-structure>`
        """
        await self.load_markets()
        request: dict = {}
        if limit is not None:
            request['limit'] = limit
        response = await self.v1PrivateGetAccountDeposits(self.extend(request, params))
        #
        #    [
        #        {
        #            "id": "238644",
        #            "symbol": "SOL",
        #            "amount": "0.104",
        #            "time": "1753436404000000",
        #            "confirmed": True,
        #            "transactionHash": "1DRxbbyePTsMuB82SDf2fG5gLXH5iYnY8TQDstDPLULpLtjMJtF1ug1T4Mf8B6DSb8fp2sb5YtdbyqieZ2tkE1Ve",
        #            "chain": "Solana",
        #            "depositAddress": "12NauJ26TUT9aYkpId7YdePJJDRMGbAsEMVoTVUvBErV",
        #            "price": "180.322010164"
        #        }
        #    ]
        #
        currency = None
        if code is not None:
            currency = self.currency(code)
        return self.parse_transactions(response, currency, since, limit)

    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
        #
        #        {
        #            "id": "238644",
        #            "symbol": "SOL",
        #            "amount": "0.104",
        #            "time": "1753436404000000",
        #            "confirmed": True,
        #            "transactionHash": "1DRxbbyePTsMuB82SDf2fG5gLXH5iYnY8TQDstDPLULpLtjMJtF1ug1T4Mf8B6DSb8fp2sb5YtdbyqieZ2tkE1Ve",
        #            "chain": "Solana",
        #            "depositAddress": "12NauJ26TUT9aYkpId7YdePJJDRMGbAsEMVoTVUvBErV",
        #            "price": "180.322010164"
        #        }
        #
        address = self.safe_string(transaction, 'depositAddress')
        timestamp = self.safe_integer_product(transaction, 'time', 0.001)
        confirmd = self.safe_bool(transaction, 'confirmed')
        status = None
        if confirmd:
            status = 'ok'
        currencyId = self.safe_string(transaction, 'symbol')
        code = self.safe_currency_code(currencyId, currency)
        return {
            'info': transaction,
            'id': self.safe_string(transaction, 'id'),
            'txid': self.safe_string(transaction, 'transactionHash'),
            'type': None,
            'currency': code,
            'network': self.network_id_to_code(self.safe_string(transaction, 'chain')),
            'amount': self.safe_number(transaction, 'amount'),
            'status': status,
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'address': address,
            'addressFrom': None,
            'addressTo': address,
            'tag': None,
            'tagFrom': None,
            'tagTo': None,
            'updated': None,
            'comment': None,
            'fee': None,
            'internal': False,
        }

    async def fetch_trading_fees(self, params={}) -> TradingFees:
        """
        fetch the trading fees for multiple markets

        https://arkm.com/docs#get/account/fees

        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param str [params.subType]: "linear" or "inverse"
        :returns dict: a dictionary of `fee structures <https://docs.ccxt.com/?id=fee-structure>` indexed by market symbols
        """
        await self.load_markets()
        response = await self.v1PrivateGetAccountFees(params)
        #
        # {
        #   "perpMakerFee": "1.23",
        #   "perpTakerFee": "1.23",
        #   "spotMakerFee": "1.23",
        #   "spotTakerFee": "1.23"
        # }
        #
        symbols = list(self.markets.keys())
        result: dict = {}
        spotMaker = self.safe_number(response, 'spotMakerFee')
        spotTaker = self.safe_number(response, 'spotTakerFee')
        perpMaker = self.safe_number(response, 'perpMakerFee')
        perpTaker = self.safe_number(response, 'perpTakerFee')
        for i in range(0, len(symbols)):
            symbol = symbols[i]
            market = self.markets[symbol]
            result[symbol] = {
                'info': response,
                'symbol': symbol,
            }
            if market['spot']:
                result[symbol]['maker'] = spotMaker
                result[symbol]['taker'] = spotTaker
            elif market['swap'] or market['future']:
                result[symbol]['maker'] = perpMaker
                result[symbol]['taker'] = perpTaker
        return result

    async def fetch_funding_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
        """
        fetch the history of funding payments paid and received on self account

        https://arkm.com/docs#get/account/funding-rate-payments

        :param str [symbol]: unified market symbol
        :param int [since]: the earliest time in ms to fetch funding history for
        :param int [limit]: the maximum number of funding history structures to retrieve
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
        :returns dict: a `funding history structure <https://docs.ccxt.com/?id=funding-history-structure>`
        """
        await self.load_markets()
        market = None
        if symbol is not None:
            market = self.market(symbol)
        request: dict = {}
        if limit is not None:
            request['limit'] = limit
        response = await self.v1PrivateGetAccountFundingRatePayments(self.extend(request, params))
        #
        #     [
        #         {
        #             "amount": "20.1",
        #             "assetSymbol": "BTC",
        #             "indexPrice": "1.23",
        #             "pairSymbol": "BTC_USDT",
        #             "time": 1704067200000000,
        #             "id": 1,
        #             "subaccountId": 1,
        #             "userId": 1
        #         },
        #         ...
        #     ]
        #
        return self.parse_incomes(response, market, since, limit)

    def parse_income(self, income, market: Market = None):
        #
        #         {
        #             "amount": "20.1",
        #             "assetSymbol": "BTC",
        #             "indexPrice": "1.23",
        #             "pairSymbol": "BTC_USDT",
        #             "time": 1704067200000000,
        #             "id": 1,
        #             "subaccountId": 1,
        #             "userId": 1
        #         }
        #
        marketId = self.safe_string(income, 'pairSymbol')
        currencyId = self.safe_string(income, 'assetSymbol')
        timestamp = self.safe_integer_product(income, 'time', 0.001)
        return {
            'info': income,
            'symbol': self.safe_symbol(marketId, market),
            'code': self.safe_currency_code(currencyId),
            'timestamp': timestamp,
            'datetime': self.iso8601(timestamp),
            'id': self.safe_string(income, 'id'),
            'amount': self.safe_number(income, 'amount'),
        }

    async def fetch_leverage(self, symbol: str, params={}) -> Leverage:
        """
        fetch the set leverage for a market

        https://arkm.com/docs#get/account/leverage

        :param str symbol: unified market symbol
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `leverage structure <https://docs.ccxt.com/?id=leverage-structure>`
        """
        await self.load_markets()
        market = self.market(symbol)
        marketId = self.safe_string(market, 'id')
        request: dict = {
            'symbol': marketId,
        }
        response = await self.v1PrivateGetAccountLeverage(self.extend(request, params))
        #
        # might be empty if not changed from default value(which is 1x)
        #
        #    [
        #        {
        #            "symbol": "BTC_USDT_PERP",
        #            "leverage": "7"
        #        },
        #        {
        #            "symbol": "ETH_USDT_PERP",
        #            "leverage": "5"
        #        }
        #    ]
        #
        indexed = self.index_by(response, 'symbol')
        data = self.safe_dict(indexed, marketId, {})
        return self.parse_leverage(data, market)

    def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
        #
        #        {
        #            "symbol": "ETH_USDT_PERP",
        #            "leverage": "5"
        #        }
        #
        marketId = self.safe_string(leverage, 'symbol')
        leverageNum = self.safe_number(leverage, 'leverage')  # default leverage is 1 typically
        return {
            'info': leverage,
            'symbol': self.safe_symbol(marketId, market),
            'marginMode': None,
            'longLeverage': leverageNum,
            'shortLeverage': leverageNum,
        }

    async def set_leverage(self, leverage: int, symbol: Str = None, params={}):
        """
        set the level of leverage for a market

        https://arkm.com/docs#post/account/leverage

        :param float leverage: the rate of leverage
        :param str symbol: unified market symbol
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: response from the exchange
        """
        if symbol is None:
            raise ArgumentsRequired(self.id + ' setLeverage() requires a symbol argument')
        await self.load_markets()
        market = self.market(symbol)
        leverageString = self.number_to_string(leverage)
        marketId = self.safe_string(market, 'id')
        request: dict = {
            'symbol': marketId,
            'leverage': leverageString,
        }
        response = await self.v1PrivatePostAccountLeverage(self.extend(request, params))
        #
        # response is just empty string
        #
        return self.parse_leverage(response, market)

    async def fetch_positions(self, symbols: Strings = None, params={}) -> List[Position]:
        """
        fetch all open positions

        https://arkm.com/docs#get/account/positions

        :param str[]|None symbols: list of unified market symbols
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :param boolean [params.standard]: whether to fetch standard contract positions
        :returns dict[]: a list of `position structures <https://docs.ccxt.com/?id=position-structure>`
        """
        await self.load_markets()
        symbols = self.market_symbols(symbols)
        response = await self.v1PrivateGetAccountPositions(params)
        #
        #    [
        #        {
        #            "subaccountId": "0",
        #            "symbol": "SOL_USDT_PERP",
        #            "base": "0.037",
        #            "quote": "-6.44614",
        #            "openBuySize": "0",
        #            "openSellSize": "0",
        #            "openBuyNotional": "0",
        #            "openSellNotional": "0",
        #            "lastUpdateReason": "orderFill",
        #            "lastUpdateTime": "1753903829389966",
        #            "lastUpdateId": "250434684",
        #            "lastUpdateBaseDelta": "0.037",
        #            "lastUpdateQuoteDelta": "-6.44614",
        #            "breakEvenPrice": "174.22",
        #            "markPrice": "174.33",
        #            "value": "6.45021",
        #            "pnl": "0.00407",
        #            "initialMargin": "0.645021",
        #            "maintenanceMargin": "0.3870126",
        #            "averageEntryPrice": "174.22"
        #        }
        #    ]
        #
        return self.parse_positions(response, symbols)

    def parse_position(self, position: dict, market: Market = None):
        #
        #        {
        #            "subaccountId": "0",
        #            "symbol": "SOL_USDT_PERP",
        #            "base": "0.037",                             # negative for short position
        #            "quote": "-6.44614",                         # negative for long position
        #            "openBuySize": "0",
        #            "openSellSize": "0",
        #            "openBuyNotional": "0",
        #            "openSellNotional": "0",
        #            "lastUpdateReason": "orderFill",
        #            "lastUpdateTime": "1753903829389966",
        #            "lastUpdateId": "250434684",
        #            "lastUpdateBaseDelta": "0.037",
        #            "lastUpdateQuoteDelta": "-6.44614",
        #            "breakEvenPrice": "174.22",
        #            "markPrice": "174.33",
        #            "value": "6.45021",
        #            "pnl": "0.00407",
        #            "initialMargin": "0.645021",
        #            "maintenanceMargin": "0.3870126",
        #            "averageEntryPrice": "174.22"
        #        }
        #
        base = self.safe_string(position, 'base')
        baseAbs = Precise.string_abs(base)
        isLong = Precise.string_ge(base, '0')
        side = 'long' if isLong else 'short'
        marketId = self.safe_string(position, 'symbol')
        notional = self.safe_string(position, 'value')
        return self.safe_position({
            'info': position,
            'id': None,
            'symbol': self.safe_symbol(marketId, market),
            'notional': self.parse_number(Precise.string_abs(notional)),
            'marginMode': None,
            'liquidationPrice': None,
            'entryPrice': self.safe_number(position, 'averageEntryPrice'),
            'unrealizedPnl': self.safe_number(position, 'pnl'),
            'realizedPnl': None,
            'percentage': None,
            'contracts': self.parse_number(baseAbs),
            'contractSize': None,
            'markPrice': self.safe_number(position, 'markPrice'),
            'lastPrice': None,
            'side': side,
            'hedged': None,
            'timestamp': None,
            'datetime': None,
            'lastUpdateTimestamp': self.safe_integer(position, 'lastUpdateTime'),
            'maintenanceMargin': self.safe_number(position, 'maintenanceMargin'),
            'maintenanceMarginPercentage': None,
            'collateral': None,
            'initialMargin': self.safe_number(position, 'initialMargin'),
            'initialMarginPercentage': None,
            'leverage': None,
            'marginRatio': None,
            'stopLossPrice': None,
            'takeProfitPrice': None,
        })

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

        https://arkm.com/docs#post/account/withdraw
        https://arkm.com/docs#get/account/withdrawal/addresses

        :param str code: unified currency code
        :param float amount: the amount to withdraw
        :param str address: the address to withdraw to
        :param str tag:
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a `transaction structure <https://docs.ccxt.com/?id=transaction-structure>`
        """
        tag, params = self.handle_withdraw_tag_and_params(tag, params)
        await self.load_markets()
        withdrawalAddresses = await self.v1PrivateGetAccountWithdrawalAddresses()
        #
        #    [
        #        {
        #            "id": "12345",
        #            "chain": "ETH",
        #            "address": "0x743f79D65EA07AA222F4a83c10dee4210A920a6e",
        #            "label": "my_binance",
        #            "createdAt": "1753905200074355",
        #            "updatedAt": "1753905213464278",
        #            "confirmed": True
        #        }
        #    ]
        #
        currency = self.currency(code)
        request: dict = {
            'symbol': currency['id'],
            'amount': self.currency_to_precision(code, amount),
            'subaccountId': self.safe_integer(params, 'subAccountId', 0),
        }
        networkCode = None
        networkCode, params = self.handle_network_code_and_params(params)
        if networkCode is None:
            raise ArgumentsRequired(self.id + ' withdraw() requires a "network" param')
        indexedList = self.group_by(withdrawalAddresses, 'address')
        if not (address in indexedList):
            raise InvalidAddress(self.id + ' withdraw() requires an address that has been previously added to the whitelisted addresses')
        withdrawalObjects = indexedList[address]
        foundWithdrawalObject = None
        for i in range(0, len(withdrawalObjects)):
            withdrawalObject = withdrawalObjects[i]
            if withdrawalObject['chain'] == networkCode:
                foundWithdrawalObject = withdrawalObject
                break
        if foundWithdrawalObject is None:
            raise InvalidAddress(self.id + ' withdraw() can not find whitelisted withdrawal address for ' + address + ' with network ' + networkCode)
        request['addressId'] = self.safe_integer(foundWithdrawalObject, 'id')
        response = await self.v1PrivatePostAccountWithdraw(self.extend(request, params))
        #
        # response is a weird string like:
        #
        #    "1234709779980\\n"
        #
        responseString = response.replace('\n', '')
        data = {'id': responseString}
        return self.parse_transaction(data, currency)

    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}) -> LeverageTiers:
        """
        retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes

        https://arkm.com/docs#get/public/margin-schedules

        :param str[]|None symbols: list of unified market symbols
        :param dict [params]: extra parameters specific to the exchange API endpoint
        :returns dict: a dictionary of `leverage tiers structures <https://docs.ccxt.com/?id=leverage-tiers-structure>`, indexed by market symbols
        """
        await self.load_markets()
        if symbols is None:
            raise ArgumentsRequired(self.id + ' fetchLeverageTiers() requires a symbols argument')
        symbols = self.market_symbols(symbols)
        response = await self.v1PublicGetMarginSchedules(params)
        #
        #    [
        #        {
        #            "name": "A",
        #            "bands": [
        #                {
        #                    "positionLimit": "1000000",
        #                    "leverageRate": "50",
        #                    "marginRate": "0.02",
        #                    "rebate": "0"
        #                },
        #                {
        #                    "positionLimit": "2000000",
        #                    "leverageRate": "25",
        #                    "marginRate": "0.04",
        #                    "rebate": "20000"
        #                },
        #                {
        #                    "positionLimit": "5000000",
        #                    "leverageRate": "20",
        #                    "marginRate": "0.05",
        #                    "rebate": "40000"
        #                }
        #            ]
        #        },
        #        {
        #            "name": "B",
        #            ...
        #
        return self.parse_leverage_tiers(response, symbols)

    def parse_leverage_tiers(self, response: Any, symbols: List[str] = None, marketIdKey=None) -> LeverageTiers:
        # overloaded method
        indexed = self.index_by(response, 'name')
        symbols = self.market_symbols(symbols)
        tiers = {}
        for i in range(0, len(symbols)):
            symbol = symbols[i]
            market = self.market(symbol)
            marginSchedule = self.safe_string(market['info'], 'marginSchedule')
            if marginSchedule is None:
                raise BadSymbol(self.id + ' fetchLeverageTiers() could not find marginSchedule for ' + symbol)
            selectedDict = self.safe_dict(indexed, marginSchedule, {})
            bands = self.safe_list(selectedDict, 'bands', [])
            tiers[symbol] = self.parse_market_leverage_tiers(bands, market)
        return tiers

    def parse_market_leverage_tiers(self, info, market: Market = None) -> List[LeverageTier]:
        tiers = []
        brackets = info
        minNotional = 0
        for i in range(0, len(brackets)):
            tier = brackets[i]
            marketId = self.safe_string(info, 'market')
            market = self.safe_market(marketId, market, None, 'swap')
            maxNotional = self.safe_number(tier, 'positionLimit')
            curr = market['base'] if market['linear'] else market['quote']
            notional = minNotional
            tiers.append({
                'tier': self.sum(i, 1),
                'symbol': self.safe_symbol(marketId, market, None, 'swap'),
                'currency': curr,
                'minNotional': notional,
                'maxNotional': maxNotional,
                'maintenanceMarginRate': self.safe_number(tier, 'marginRate'),
                'maxLeverage': self.safe_integer(tier, 'leverageRate'),
                'info': tier,
            })
            minNotional = maxNotional
        return tiers

    def find_timeframe_by_duration(self, duration: Int) -> str:
        # self method is used to find the timeframe by duration in seconds
        timeframes = self.safe_dict(self.options, 'timeframeDurations', {})
        keys = list(timeframes.keys())
        for i in range(0, len(keys)):
            timeframe = keys[i]
            durationInMicroseconds = self.safe_integer(timeframes, timeframe)
            if durationInMicroseconds == duration:
                return timeframe
        return None

    def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
        type = self.safe_string(api, 0)
        access = self.safe_string(api, 1)
        accessPart = access + '/' if (access == 'public') else ''
        query = self.omit(params, self.extract_params(path))
        path = self.implode_params(path, params)
        url = self.urls['api'][type] + '/' + accessPart + path
        queryString = ''
        if method == 'GET':
            if query:
                queryString = self.urlencode(query)
                url += '?' + queryString
        if access == 'private':
            self.check_required_credentials()
            expires = (self.milliseconds() + self.safe_integer(self.options, 'requestExpiration', 5000)) * 1000  # need macroseconds
            if method == 'POST':
                body = self.json(params)
            if queryString != '':
                path = path + '?' + queryString
            bodyStr = body if (body is not None) else ''
            payload = self.apiKey + str(expires) + method.upper() + '/' + path + bodyStr
            decodedSecret = self.base64_to_binary(self.secret)
            signature = self.hmac(self.encode(payload), decodedSecret, hashlib.sha256, 'base64')
            headers = {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
                'Arkham-Api-Key': self.apiKey,
                'Arkham-Expires': str(expires),
                'Arkham-Signature': signature,
                'Arkham-Broker-Id': '1001',
            }
        return {'url': url, 'method': method, 'body': body, 'headers': headers}

    def handle_errors(self, code: int, reason: str, url: str, method: str, headers: dict, body: str, response, requestHeaders, requestBody):
        #
        # error example:
        #
        #    {
        #        "id": "30005",
        #        "name": "InvalidNotional",
        #        "message": "order validation failed: invalid notional: notional 0.25 is less than min notional 1"
        #    }
        #
        message = self.safe_string(response, 'message')
        if message is not None:
            errorCode = self.safe_string(response, 'id')
            feedback = self.id + ' ' + body
            self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
            self.throw_exactly_matched_exception(self.exceptions['exact'], message, feedback)
            self.throw_broadly_matched_exception(self.exceptions['broad'], message, feedback)
            raise ExchangeError(self.id + ' ' + body)
        return None
