ccxt 4.2.18 → 4.2.19

package/dist/cjs/js/src/krakenfutures.js

@@ -1,2407 +0,0 @@
-'use strict';
-
-var krakenfutures$1 = require('./abstract/krakenfutures.js');
-var number = require('./base/functions/number.js');
-var errors = require('./base/errors.js');
-var Precise = require('./base/Precise.js');
-var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
-var sha512 = require('./static_dependencies/noble-hashes/sha512.js');
-
-//  ---------------------------------------------------------------------------
-//  ---------------------------------------------------------------------------
-/**
- * @class krakenfutures
- * @augments Exchange
- */
-class krakenfutures extends krakenfutures$1 {
-    describe() {
-        return this.deepExtend(super.describe(), {
-            'id': 'krakenfutures',
-            'name': 'Kraken Futures',
-            'countries': ['US'],
-            'version': 'v3',
-            'userAgent': undefined,
-            'rateLimit': 600,
-            'pro': true,
-            'has': {
-                'CORS': undefined,
-                'spot': false,
-                'margin': false,
-                'swap': true,
-                'future': true,
-                'option': false,
-                'cancelAllOrders': true,
-                'cancelOrder': true,
-                'cancelOrders': true,
-                'createMarketOrder': false,
-                'createOrder': true,
-                'editOrder': true,
-                'fetchBalance': true,
-                'fetchBorrowRateHistories': false,
-                'fetchBorrowRateHistory': false,
-                'fetchClosedOrders': undefined,
-                'fetchCrossBorrowRate': false,
-                'fetchCrossBorrowRates': false,
-                'fetchFundingHistory': undefined,
-                'fetchFundingRate': 'emulated',
-                'fetchFundingRateHistory': true,
-                'fetchFundingRates': true,
-                'fetchIndexOHLCV': false,
-                'fetchIsolatedBorrowRate': false,
-                'fetchIsolatedBorrowRates': false,
-                'fetchIsolatedPositions': false,
-                'fetchLeverage': true,
-                'fetchLeverageTiers': true,
-                'fetchMarketLeverageTiers': 'emulated',
-                'fetchMarkets': true,
-                'fetchMarkOHLCV': true,
-                'fetchMyTrades': true,
-                'fetchOHLCV': true,
-                'fetchOpenOrders': true,
-                'fetchOrder': false,
-                'fetchOrderBook': true,
-                'fetchOrders': false,
-                'fetchPositions': true,
-                'fetchPremiumIndexOHLCV': false,
-                'fetchTickers': true,
-                'fetchTrades': true,
-                'setLeverage': true,
-                'setMarginMode': false,
-                'transfer': true,
-            },
-            'urls': {
-                'test': {
-                    'public': 'https://demo-futures.kraken.com/derivatives/api/',
-                    'private': 'https://demo-futures.kraken.com/derivatives/api/',
-                    'charts': 'https://demo-futures.kraken.com/api/charts/',
-                    'www': 'https://demo-futures.kraken.com',
-                },
-                'logo': 'https://user-images.githubusercontent.com/24300605/81436764-b22fd580-9172-11ea-9703-742783e6376d.jpg',
-                'api': {
-                    'charts': 'https://futures.kraken.com/api/charts/',
-                    'history': 'https://futures.kraken.com/api/history/',
-                    'feeschedules': 'https://futures.kraken.com/api/feeschedules/',
-                    'public': 'https://futures.kraken.com/derivatives/api/',
-                    'private': 'https://futures.kraken.com/derivatives/api/',
-                },
-                'www': 'https://futures.kraken.com/',
-                'doc': [
-                    'https://docs.futures.kraken.com/#introduction',
-                ],
-                'fees': 'https://support.kraken.com/hc/en-us/articles/360022835771-Transaction-fees-and-rebates-for-Kraken-Futures',
-                'referral': undefined,
-            },
-            'api': {
-                'public': {
-                    'get': [
-                        'feeschedules',
-                        'instruments',
-                        'orderbook',
-                        'tickers',
-                        'history',
-                        'historicalfundingrates',
-                    ],
-                },
-                'private': {
-                    'get': [
-                        'feeschedules/volumes',
-                        'openpositions',
-                        'notifications',
-                        'accounts',
-                        'openorders',
-                        'recentorders',
-                        'fills',
-                        'transfers',
-                        'leveragepreferences',
-                        'pnlpreferences',
-                    ],
-                    'post': [
-                        'sendorder',
-                        'editorder',
-                        'cancelorder',
-                        'transfer',
-                        'batchorder',
-                        'cancelallorders',
-                        'cancelallordersafter',
-                        'withdrawal', // for futures wallet -> kraken spot wallet
-                    ],
-                    'put': [
-                        'leveragepreferences',
-                        'pnlpreferences',
-                    ],
-                },
-                'charts': {
-                    'get': [
-                        '{price_type}/{symbol}/{interval}',
-                    ],
-                },
-                'history': {
-                    'get': [
-                        'orders',
-                        'executions',
-                        'triggers',
-                        'accountlogcsv',
-                        'market/{symbol}/orders',
-                        'market/{symbol}/executions',
-                    ],
-                },
-            },
-            'fees': {
-                'trading': {
-                    'tierBased': false,
-                    'percentage': true,
-                    'maker': this.parseNumber('-0.0002'),
-                    'taker': this.parseNumber('0.00075'),
-                },
-            },
-            'exceptions': {
-                'exact': {
-                    'apiLimitExceeded': errors.RateLimitExceeded,
-                    'marketUnavailable': errors.ContractUnavailable,
-                    'requiredArgumentMissing': errors.BadRequest,
-                    'unavailable': errors.ExchangeNotAvailable,
-                    'authenticationError': errors.AuthenticationError,
-                    'accountInactive': errors.ExchangeError,
-                    'invalidAccount': errors.BadRequest,
-                    'invalidAmount': errors.BadRequest,
-                    'insufficientFunds': errors.InsufficientFunds,
-                    'Bad Request': errors.BadRequest,
-                    'Unavailable': errors.InsufficientFunds,
-                    'invalidUnit': errors.BadRequest,
-                    'Json Parse Error': errors.ExchangeError,
-                    'nonceBelowThreshold': errors.InvalidNonce,
-                    'nonceDuplicate': errors.InvalidNonce,
-                    'notFound': errors.BadRequest,
-                    'Server Error': errors.ExchangeError,
-                    'unknownError': errors.ExchangeError,
-                },
-                'broad': {
-                    'invalidArgument': errors.BadRequest,
-                    'nonceBelowThreshold': errors.InvalidNonce,
-                    'nonceDuplicate': errors.InvalidNonce,
-                },
-            },
-            'precisionMode': number.TICK_SIZE,
-            'options': {
-                'access': {
-                    'history': {
-                        'GET': {
-                            'orders': 'private',
-                            'executions': 'private',
-                            'triggers': 'private',
-                            'accountlogcsv': 'private',
-                        },
-                    },
-                },
-                'settlementCurrencies': {
-                    'flex': ['USDT', 'BTC', 'USD', 'GBP', 'EUR', 'USDC'],
-                },
-                'symbol': {
-                    'quoteIds': ['USD', 'XBT'],
-                    'reversed': false,
-                },
-                'versions': {
-                    'public': {
-                        'GET': {
-                            'historicalfundingrates': 'v4',
-                        },
-                    },
-                    'charts': {
-                        'GET': {
-                            '{price_type}/{symbol}/{interval}': 'v1',
-                        },
-                    },
-                    'history': {
-                        'GET': {
-                            'orders': 'v2',
-                            'executions': 'v2',
-                            'triggers': 'v2',
-                            'accountlogcsv': 'v2',
-                        },
-                    },
-                },
-            },
-            'timeframes': {
-                '1m': '1m',
-                '5m': '5m',
-                '15m': '15m',
-                '30m': '30m',
-                '1h': '1h',
-                '4h': '4h',
-                '12h': '12h',
-                '1d': '1d',
-                '1w': '1w',
-            },
-        });
-    }
-    async fetchMarkets(params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchMarkets
-         * @description Fetches the available trading markets from the exchange, Multi-collateral markets are returned as linear markets, but can be settled in multiple currencies
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-instrument-details-get-instruments
-         * @param {object} [params] exchange specific params
-         * @returns An array of market structures
-         */
-        const response = await this.publicGetInstruments(params);
-        //
-        //    {
-        //        "result": "success",
-        //        "instruments": [
-        //            {
-        //                "symbol": "fi_ethusd_180928",
-        //                "type": "futures_inverse", // futures_vanilla  // spot index
-        //                "underlying": "rr_ethusd",
-        //                "lastTradingTime": "2018-09-28T15:00:00.000Z",
-        //                "tickSize": 0.1,
-        //                "contractSize": 1,
-        //                "tradeable": true,
-        //                "marginLevels": [
-        //                    {
-        //                        "contracts":0,
-        //                        "initialMargin":0.02,
-        //                        "maintenanceMargin":0.01
-        //                    },
-        //                    {
-        //                        "contracts":250000,
-        //                        "initialMargin":0.04,
-        //                        "maintenanceMargin":0.02
-        //                    },
-        //                    ...
-        //                ],
-        //                "isin": "GB00JVMLMP88",
-        //                "retailMarginLevels": [
-        //                    {
-        //                        "contracts": 0,
-        //                        "initialMargin": 0.5,
-        //                        "maintenanceMargin": 0.25
-        //                    }
-        //                ],
-        //                "tags": [],
-        //            },
-        //            {
-        //                "symbol": "in_xbtusd",
-        //                "type": "spot index",
-        //                "tradeable":false
-        //            }
-        //        ]
-        //        "serverTime": "2018-07-19T11:32:39.433Z"
-        //    }
-        //
-        const instruments = this.safeValue(response, 'instruments', []);
-        const result = [];
-        for (let i = 0; i < instruments.length; i++) {
-            const market = instruments[i];
-            const id = this.safeString(market, 'symbol');
-            const marketType = this.safeString(market, 'type');
-            let type = undefined;
-            const index = (marketType.indexOf(' index') >= 0);
-            let linear = undefined;
-            let inverse = undefined;
-            let expiry = undefined;
-            if (!index) {
-                linear = (marketType.indexOf('_vanilla') >= 0);
-                inverse = !linear;
-                const settleTime = this.safeString(market, 'lastTradingTime');
-                type = (settleTime === undefined) ? 'swap' : 'future';
-                expiry = this.parse8601(settleTime);
-            }
-            else {
-                type = 'index';
-            }
-            const swap = (type === 'swap');
-            const future = (type === 'future');
-            let symbol = id;
-            const split = id.split('_');
-            const splitMarket = this.safeString(split, 1);
-            const baseId = splitMarket.slice(0, splitMarket.length - 3);
-            const quoteId = 'usd'; // always USD
-            const base = this.safeCurrencyCode(baseId);
-            const quote = this.safeCurrencyCode(quoteId);
-            // swap == perpetual
-            let settle = undefined;
-            let settleId = undefined;
-            const amountPrecision = this.parseNumber(this.parsePrecision(this.safeString(market, 'contractValueTradePrecision', '0')));
-            const pricePrecision = this.safeNumber(market, 'tickSize');
-            const contract = (swap || future || index);
-            const swapOrFutures = (swap || future);
-            if (swapOrFutures) {
-                const exchangeType = this.safeString(market, 'type');
-                if (exchangeType === 'futures_inverse') {
-                    settle = base;
-                    settleId = baseId;
-                    inverse = true;
-                }
-                else {
-                    settle = quote;
-                    settleId = quoteId;
-                    inverse = false;
-                }
-                linear = !inverse;
-                symbol = base + '/' + quote + ':' + settle;
-                if (future) {
-                    symbol = symbol + '-' + this.yymmdd(expiry);
-                }
-            }
-            result.push({
-                'id': id,
-                'symbol': symbol,
-                'base': base,
-                'quote': quote,
-                'settle': settle,
-                'baseId': baseId,
-                'quoteId': quoteId,
-                'settleId': settleId,
-                'type': type,
-                'spot': false,
-                'margin': false,
-                'swap': swap,
-                'future': future,
-                'option': false,
-                'index': index,
-                'active': undefined,
-                'contract': contract,
-                'linear': linear,
-                'inverse': inverse,
-                'contractSize': this.safeNumber(market, 'contractSize'),
-                'maintenanceMarginRate': undefined,
-                'expiry': expiry,
-                'expiryDatetime': this.iso8601(expiry),
-                'strike': undefined,
-                'optionType': undefined,
-                'precision': {
-                    'amount': amountPrecision,
-                    'price': pricePrecision,
-                },
-                'limits': {
-                    'leverage': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'price': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'cost': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                },
-                'created': this.parse8601(this.safeString(market, 'openingDate')),
-                'info': market,
-            });
-        }
-        const settlementCurrencies = this.options['settlementCurrencies']['flex'];
-        const currencies = [];
-        for (let i = 0; i < settlementCurrencies.length; i++) {
-            const code = settlementCurrencies[i];
-            currencies.push({
-                'id': code.toLowerCase(),
-                'numericId': undefined,
-                'code': code,
-                'precision': undefined,
-            });
-        }
-        this.currencies = this.deepExtend(currencies, this.currencies);
-        return result;
-    }
-    async fetchOrderBook(symbol, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchOrderBook
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-market-data-get-orderbook
-         * @description Fetches a list of open orders in a market
-         * @param {string} symbol Unified market symbol
-         * @param {int} [limit] Not used by krakenfutures
-         * @param {object} [params] exchange specific params
-         * @returns An [order book structure]{@link https://docs.ccxt.com/#/?id=order-book-structure}
-         */
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = {
-            'symbol': market['id'],
-        };
-        const response = await this.publicGetOrderbook(this.extend(request, params));
-        //
-        //    {
-        //       "result": "success",
-        //       "serverTime": "2016-02-25T09:45:53.818Z",
-        //       "orderBook": {
-        //          "bids": [
-        //                [
-        //                    4213,
-        //                    2000,
-        //                ],
-        //                [
-        //                    4210,
-        //                    4000,
-        //                ],
-        //                ...
-        //            ],
-        //            "asks": [
-        //                [
-        //                    4218,
-        //                    4000,
-        //                ],
-        //                [
-        //                    4220,
-        //                    5000,
-        //                ],
-        //                ...
-        //            ],
-        //        },
-        //    }
-        //
-        const timestamp = this.parse8601(response['serverTime']);
-        return this.parseOrderBook(response['orderBook'], symbol, timestamp);
-    }
-    async fetchTickers(symbols = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchTickers
-         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-market-data-get-tickers
-         * @param {string[]} symbols unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} an array of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
-         */
-        await this.loadMarkets();
-        const response = await this.publicGetTickers(params);
-        //
-        //    {
-        //        "result": "success",
-        //        "tickers": [
-        //            {
-        //                "tag": 'semiannual',  // 'month', 'quarter', "perpetual", "semiannual",
-        //                "pair": "ETH:USD",
-        //                "symbol": "fi_ethusd_220624",
-        //                "markPrice": "2925.72",
-        //                "bid": "2923.8",
-        //                "bidSize": "16804",
-        //                "ask": "2928.65",
-        //                "askSize": "1339",
-        //                "vol24h": "860493",
-        //                "openInterest": "3023363.00000000",
-        //                "open24h": "3021.25",
-        //                "indexPrice": "2893.71",
-        //                "last": "2942.25",
-        //                "lastTime": "2022-02-18T14:08:15.578Z",
-        //                "lastSize": "151",
-        //                "suspended": false
-        //            },
-        //            {
-        //                "symbol": "in_xbtusd", // "rr_xbtusd",
-        //                "last": "40411",
-        //                "lastTime": "2022-02-18T14:16:28.000Z"
-        //            },
-        //            ...
-        //        ],
-        //        "serverTime": "2022-02-18T14:16:29.440Z"
-        //    }
-        //
-        const tickers = this.safeValue(response, 'tickers');
-        return this.parseTickers(tickers, symbols);
-    }
-    parseTicker(ticker, market = undefined) {
-        //
-        //    {
-        //        "tag": 'semiannual',  // 'month', 'quarter', "perpetual", "semiannual",
-        //        "pair": "ETH:USD",
-        //        "symbol": "fi_ethusd_220624",
-        //        "markPrice": "2925.72",
-        //        "bid": "2923.8",
-        //        "bidSize": "16804",
-        //        "ask": "2928.65",
-        //        "askSize": "1339",
-        //        "vol24h": "860493",
-        //        "openInterest": "3023363.00000000",
-        //        "open24h": "3021.25",
-        //        "indexPrice": "2893.71",
-        //        "last": "2942.25",
-        //        "lastTime": "2022-02-18T14:08:15.578Z",
-        //        "lastSize": "151",
-        //        "suspended": false
-        //    }
-        //
-        //    {
-        //        "symbol": "in_xbtusd", // "rr_xbtusd",
-        //        "last": "40411",
-        //        "lastTime": "2022-02-18T14:16:28.000Z"
-        //    }
-        //
-        const marketId = this.safeString(ticker, 'symbol');
-        market = this.safeMarket(marketId, market);
-        const symbol = market['symbol'];
-        const timestamp = this.parse8601(this.safeString(ticker, 'lastTime'));
-        const open = this.safeString(ticker, 'open24h');
-        const last = this.safeString(ticker, 'last');
-        const change = Precise["default"].stringSub(last, open);
-        const percentage = Precise["default"].stringMul(Precise["default"].stringDiv(change, open), '100');
-        const average = Precise["default"].stringDiv(Precise["default"].stringAdd(open, last), '2');
-        const volume = this.safeString(ticker, 'vol24h');
-        let baseVolume = undefined;
-        let quoteVolume = undefined;
-        const isIndex = this.safeValue(market, 'index', false);
-        if (!isIndex) {
-            if (market['linear']) {
-                baseVolume = volume;
-            }
-            else if (market['inverse']) {
-                quoteVolume = volume;
-            }
-        }
-        return this.safeTicker({
-            'symbol': symbol,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'high': undefined,
-            'low': undefined,
-            'bid': this.safeString(ticker, 'bid'),
-            'bidVolume': this.safeString(ticker, 'bidSize'),
-            'ask': this.safeString(ticker, 'ask'),
-            'askVolume': this.safeString(ticker, 'askSize'),
-            'vwap': undefined,
-            'open': open,
-            'close': last,
-            'last': last,
-            'previousClose': undefined,
-            'change': change,
-            'percentage': percentage,
-            'average': average,
-            'baseVolume': baseVolume,
-            'quoteVolume': quoteVolume,
-            'info': ticker,
-        });
-    }
-    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name kraken#fetchOHLCV
-         * @see https://docs.futures.kraken.com/#http-api-charts-candles
-         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
-         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
-         * @param {string} 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 {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this 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 as timestamp, open, high, low, close, volume
-         */
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        let paginate = false;
-        [paginate, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'paginate');
-        if (paginate) {
-            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 5000);
-        }
-        const request = {
-            'symbol': market['id'],
-            'price_type': this.safeString(params, 'price', 'trade'),
-            'interval': this.timeframes[timeframe],
-        };
-        params = this.omit(params, 'price');
-        if (since !== undefined) {
-            const duration = this.parseTimeframe(timeframe);
-            request['from'] = this.parseToInt(since / 1000);
-            if (limit === undefined) {
-                limit = 5000;
-            }
-            else if (limit > 5000) {
-                throw new errors.BadRequest(this.id + ' fetchOHLCV() limit cannot exceed 5000');
-            }
-            const toTimestamp = this.sum(request['from'], limit * duration - 1);
-            const currentTimestamp = this.seconds();
-            request['to'] = Math.min(toTimestamp, currentTimestamp);
-        }
-        else if (limit !== undefined) {
-            if (limit > 5000) {
-                throw new errors.BadRequest(this.id + ' fetchOHLCV() limit cannot exceed 5000');
-            }
-            const duration = this.parseTimeframe(timeframe);
-            request['to'] = this.seconds();
-            request['from'] = this.parseToInt(request['to'] - (duration * limit));
-        }
-        const response = await this.chartsGetPriceTypeSymbolInterval(this.extend(request, params));
-        //
-        //    {
-        //        "candles": [
-        //            {
-        //                "time": 1645198500000,
-        //                "open": "309.15000000000",
-        //                "high": "309.15000000000",
-        //                "low": "308.70000000000",
-        //                "close": "308.85000000000",
-        //                "volume": 0
-        //            }
-        //        ],
-        //        "more_candles": true
-        //    }
-        //
-        const candles = this.safeValue(response, 'candles');
-        return this.parseOHLCVs(candles, market, timeframe, since, limit);
-    }
-    parseOHLCV(ohlcv, market = undefined) {
-        //
-        //    {
-        //        "time": 1645198500000,
-        //        "open": "309.15000000000",
-        //        "high": "309.15000000000",
-        //        "low": "308.70000000000",
-        //        "close": "308.85000000000",
-        //        "volume": 0
-        //    }
-        //
-        return [
-            this.safeInteger(ohlcv, 'time'),
-            this.safeNumber(ohlcv, 'open'),
-            this.safeNumber(ohlcv, 'high'),
-            this.safeNumber(ohlcv, 'low'),
-            this.safeNumber(ohlcv, 'close'),
-            this.safeNumber(ohlcv, 'volume'), // trading volume, undefined for mark or index price
-        ];
-    }
-    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchTrades
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-market-data-get-trade-history
-         * @description Fetch a history of filled trades that this account has made
-         * @param {string} symbol Unified CCXT market symbol
-         * @param {int} [since] Timestamp in ms of earliest trade. Not used by krakenfutures except in combination with params.until
-         * @param {int} [limit] Total number of trades, cannot exceed 100
-         * @param {object} [params] Exchange specific params
-         * @param {int} [params.until] Timestamp in ms of latest trade
-         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
-         * @returns An array of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
-         */
-        await this.loadMarkets();
-        let paginate = false;
-        [paginate, params] = this.handleOptionAndParams(params, 'fetchTrades', 'paginate');
-        if (paginate) {
-            return await this.fetchPaginatedCallDynamic('fetchTrades', symbol, since, limit, params);
-        }
-        const market = this.market(symbol);
-        const request = {
-            'symbol': market['id'],
-        };
-        const until = this.safeInteger(params, 'until');
-        if (until !== undefined) {
-            request['lastTime'] = this.iso8601(until);
-        }
-        //
-        //    {
-        //        "result": "success",
-        //        "history": [
-        //            {
-        //                "time": "2022-03-18T04:55:37.692Z",
-        //                "trade_id": 100,
-        //                "price": 0.7921,
-        //                "size": 1068,
-        //                "side": "sell",
-        //                "type": "fill",
-        //                "uid": "6c5da0b0-f1a8-483f-921f-466eb0388265"
-        //            },
-        //            ...
-        //        ],
-        //        "serverTime": "2022-03-18T06:39:18.056Z"
-        //    }
-        //
-        const response = await this.publicGetHistory(this.extend(request, params));
-        const history = this.safeValue(response, 'history');
-        return this.parseTrades(history, market, since, limit);
-    }
-    parseTrade(trade, market = undefined) {
-        //
-        // fetchTrades (public)
-        //
-        //    {
-        //        "time": "2019-02-14T09:25:33.920Z",
-        //        "trade_id": 100,
-        //        "price": 3574,
-        //        "size": 100,
-        //        "side": "buy",
-        //        "type": "fill"                                          // fill, liquidation, assignment, termination
-        //        "uid": "11c3d82c-9e70-4fe9-8115-f643f1b162d4"
-        //    }
-        //
-        // fetchMyTrades (private)
-        //
-        //    {
-        //        "fillTime": "2016-02-25T09:47:01.000Z",
-        //        "order_id": "c18f0c17-9971-40e6-8e5b-10df05d422f0",
-        //        "fill_id": "522d4e08-96e7-4b44-9694-bfaea8fe215e",
-        //        "cliOrdId": "d427f920-ec55-4c18-ba95-5fe241513b30",     // OPTIONAL
-        //        "symbol": "fi_xbtusd_180615",
-        //        "side": "buy",
-        //        "size": 2000,
-        //        "price": 4255,
-        //        "fillType": "maker"                                     // taker, takerAfterEdit, maker, liquidation, assignee
-        //    }
-        //
-        // execution report (createOrder, editOrder)
-        //
-        //    {
-        //        "executionId": "e1ec9f63-2338-4c44-b40a-43486c6732d7",
-        //        "price": 7244.5,
-        //        "amount": 10,
-        //        "orderPriorEdit": null,
-        //        "orderPriorExecution": {
-        //            "orderId": "61ca5732-3478-42fe-8362-abbfd9465294",
-        //            "cliOrdId": null,
-        //            "type": "lmt",
-        //            "symbol": "pi_xbtusd",
-        //            "side": "buy",
-        //            "quantity": 10,
-        //            "filled": 0,
-        //            "limitPrice": 7500,
-        //            "reduceOnly": false,
-        //            "timestamp": "2019-12-11T17:17:33.888Z",
-        //            "lastUpdateTimestamp": "2019-12-11T17:17:33.888Z"
-        //        },
-        //        "takerReducedQuantity": null,
-        //        "type": "EXECUTION"
-        //    }
-        //
-        const timestamp = this.parse8601(this.safeString2(trade, 'time', 'fillTime'));
-        const price = this.safeString(trade, 'price');
-        const amount = this.safeString2(trade, 'size', 'amount', '0.0');
-        let id = this.safeString2(trade, 'uid', 'fill_id');
-        if (id === undefined) {
-            id = this.safeString(trade, 'executionId');
-        }
-        let order = this.safeString(trade, 'order_id');
-        let symbolId = this.safeString(trade, 'symbol');
-        let side = this.safeString(trade, 'side');
-        let type = undefined;
-        const priorEdit = this.safeValue(trade, 'orderPriorEdit');
-        const priorExecution = this.safeValue(trade, 'orderPriorExecution');
-        if (priorExecution !== undefined) {
-            order = this.safeString(priorExecution, 'orderId');
-            symbolId = this.safeString(priorExecution, 'symbol');
-            side = this.safeString(priorExecution, 'side');
-            type = this.safeString(priorExecution, 'type');
-        }
-        else if (priorEdit !== undefined) {
-            order = this.safeString(priorEdit, 'orderId');
-            symbolId = this.safeString(priorEdit, 'symbol');
-            side = this.safeString(priorEdit, 'type');
-            type = this.safeString(priorEdit, 'type');
-        }
-        if (type !== undefined) {
-            type = this.parseOrderType(type);
-        }
-        let symbol = undefined;
-        if (symbolId !== undefined) {
-            market = this.safeValue(this.markets_by_id, symbolId);
-            if (market === undefined) {
-                symbol = symbolId;
-            }
-        }
-        symbol = this.safeString(market, 'symbol', symbol);
-        let cost = undefined;
-        if ((amount !== undefined) && (price !== undefined) && (market !== undefined)) {
-            const linear = this.safeValue(market, 'linear');
-            if (linear) {
-                cost = Precise["default"].stringMul(amount, price); // in quote
-            }
-            else {
-                cost = Precise["default"].stringDiv(amount, price); // in base
-            }
-            const contractSize = this.safeString(market, 'contractSize');
-            cost = Precise["default"].stringMul(cost, contractSize);
-        }
-        let takerOrMaker = undefined;
-        const fillType = this.safeString(trade, 'fillType');
-        if (fillType !== undefined) {
-            if (fillType.indexOf('taker') >= 0) {
-                takerOrMaker = 'taker';
-            }
-            else if (fillType.indexOf('maker') >= 0) {
-                takerOrMaker = 'maker';
-            }
-        }
-        return this.safeTrade({
-            'info': trade,
-            'id': id,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'symbol': symbol,
-            'order': order,
-            'type': type,
-            'side': side,
-            'takerOrMaker': takerOrMaker,
-            'price': price,
-            'amount': amount,
-            'cost': cost,
-            'fee': undefined,
-        });
-    }
-    createOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
-        const market = this.market(symbol);
-        type = this.safeString(params, 'orderType', type);
-        const timeInForce = this.safeString(params, 'timeInForce');
-        let postOnly = false;
-        [postOnly, params] = this.handlePostOnly(type === 'market', type === 'post', params);
-        if (postOnly) {
-            type = 'post';
-        }
-        else if (timeInForce === 'ioc') {
-            type = 'ioc';
-        }
-        else if (type === 'limit') {
-            type = 'lmt';
-        }
-        else if (type === 'market') {
-            type = 'mkt';
-        }
-        const request = {
-            'symbol': market['id'],
-            'side': side,
-            'size': amount,
-        };
-        const clientOrderId = this.safeString2(params, 'clientOrderId', 'cliOrdId');
-        if (clientOrderId !== undefined) {
-            request['cliOrdId'] = clientOrderId;
-        }
-        const triggerPrice = this.safeString2(params, 'triggerPrice', 'stopPrice');
-        const isTriggerOrder = triggerPrice !== undefined;
-        const stopLossTriggerPrice = this.safeString(params, 'stopLossPrice');
-        const takeProfitTriggerPrice = this.safeString(params, 'takeProfitPrice');
-        const isStopLossTriggerOrder = stopLossTriggerPrice !== undefined;
-        const isTakeProfitTriggerOrder = takeProfitTriggerPrice !== undefined;
-        const isStopLossOrTakeProfitTrigger = isStopLossTriggerOrder || isTakeProfitTriggerOrder;
-        const triggerSignal = this.safeString(params, 'triggerSignal', 'last');
-        let reduceOnly = this.safeValue(params, 'reduceOnly');
-        if (isStopLossOrTakeProfitTrigger || isTriggerOrder) {
-            request['triggerSignal'] = triggerSignal;
-        }
-        if (isTriggerOrder) {
-            type = 'stp';
-            request['stopPrice'] = this.priceToPrecision(symbol, triggerPrice);
-        }
-        else if (isStopLossOrTakeProfitTrigger) {
-            reduceOnly = true;
-            if (isStopLossTriggerOrder) {
-                type = 'stp';
-                request['stopPrice'] = this.priceToPrecision(symbol, stopLossTriggerPrice);
-            }
-            else if (isTakeProfitTriggerOrder) {
-                type = 'take_profit';
-                request['stopPrice'] = this.priceToPrecision(symbol, takeProfitTriggerPrice);
-            }
-        }
-        if (reduceOnly) {
-            request['reduceOnly'] = true;
-        }
-        request['orderType'] = type;
-        if (price !== undefined) {
-            request['limitPrice'] = price;
-        }
-        params = this.omit(params, ['clientOrderId', 'timeInForce', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice']);
-        return this.extend(request, params);
-    }
-    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#createOrder
-         * @description Create an order on the exchange
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-send-order
-         * @param {string} symbol unified market symbol
-         * @param {string} type 'limit' or 'market'
-         * @param {string} side 'buy' or 'sell'
-         * @param {float} amount number of contracts
-         * @param {float} [price] limit order price
-         * @param {bool} [params.reduceOnly] set as true if you wish the order to only reduce an existing position, any order which increases an existing position will be rejected, default is false
-         * @param {bool} [params.postOnly] set as true if you wish to make a postOnly order, default is false
-         * @param {string} [params.clientOrderId] UUID The order identity that is specified from the user, It must be globally unique
-         * @param {float} [params.triggerPrice] the price that a stop order is triggered at
-         * @param {float} [params.stopLossPrice] the price that a stop loss order is triggered at
-         * @param {float} [params.takeProfitPrice] the price that a take profit order is triggered at
-         * @param {string} [params.triggerSignal] for triggerPrice, stopLossPrice and takeProfitPrice orders, the trigger price type, 'last', 'mark' or 'index', default is 'last'
-         */
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        const orderRequest = this.createOrderRequest(symbol, type, side, amount, price, params);
-        const response = await this.privatePostSendorder(orderRequest);
-        //
-        //    {
-        //        "result": "success",
-        //        "sendStatus": {
-        //            "order_id": "salf320-e337-47ac-b345-30sdfsalj",
-        //            "status": "placed",
-        //            "receivedTime": "2022-02-28T19:32:17.122Z",
-        //            "orderEvents": [
-        //                {
-        //                    "order": {
-        //                        "orderId": "salf320-e337-47ac-b345-30sdfsalj",
-        //                        "cliOrdId": null,
-        //                        "type": "lmt",
-        //                        "symbol": "pi_xrpusd",
-        //                        "side": "buy",
-        //                        "quantity": 1,
-        //                        "filled": 0,
-        //                        "limitPrice": 0.7,
-        //                        "reduceOnly": false,
-        //                        "timestamp": "2022-02-28T19:32:17.122Z",
-        //                        "lastUpdateTimestamp": "2022-02-28T19:32:17.122Z"
-        //                    },
-        //                    "reducedQuantity": null,
-        //                    "type": "PLACE"
-        //                }
-        //            ]
-        //        },
-        //        "serverTime": "2022-02-28T19:32:17.122Z"
-        //    }
-        //
-        const sendStatus = this.safeValue(response, 'sendStatus');
-        const status = this.safeString(sendStatus, 'status');
-        this.verifyOrderActionSuccess(status, 'createOrder', ['filled']);
-        return this.parseOrder(sendStatus, market);
-    }
-    async createOrders(orders, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#createOrders
-         * @description create a list of trade orders
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-batch-order-management
-         * @param {Array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
-         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
-        await this.loadMarkets();
-        const ordersRequests = [];
-        for (let i = 0; i < orders.length; i++) {
-            const rawOrder = orders[i];
-            const marketId = this.safeString(rawOrder, 'symbol');
-            const type = this.safeString(rawOrder, 'type');
-            const side = this.safeString(rawOrder, 'side');
-            const amount = this.safeValue(rawOrder, 'amount');
-            const price = this.safeValue(rawOrder, 'price');
-            const orderParams = this.safeValue(rawOrder, 'params', {});
-            const extendedParams = this.extend(orderParams, params); // the request does not accept extra params since it's a list, so we're extending each order with the common params
-            if (!('order_tag' in extendedParams)) {
-                // order tag is mandatory so we will generate one if not provided
-                extendedParams['order_tag'] = this.sum(i, 1).toString(); // sequential counter
-            }
-            extendedParams['order'] = 'send';
-            const orderRequest = this.createOrderRequest(marketId, type, side, amount, price, extendedParams);
-            ordersRequests.push(orderRequest);
-        }
-        const request = {
-            'batchOrder': ordersRequests,
-        };
-        const response = await this.privatePostBatchorder(this.extend(request, params));
-        //
-        // {
-        //     "result": "success",
-        //     "serverTime": "2023-10-24T08:40:57.339Z",
-        //     "batchStatus": [
-        //        {
-        //           "status": "requiredArgumentMissing",
-        //           "orderEvents": []
-        //        },
-        //        {
-        //           "status": "requiredArgumentMissing",
-        //           "orderEvents": []
-        //        }
-        //     ]
-        // }
-        //
-        const data = this.safeValue(response, 'batchStatus', []);
-        return this.parseOrders(data);
-    }
-    async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#editOrder
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-edit-order
-         * @description Edit an open order on the exchange
-         * @param {string} id order id
-         * @param {string} symbol Not used by Krakenfutures
-         * @param {string} type Not used by Krakenfutures
-         * @param {string} side Not used by Krakenfutures
-         * @param {float} amount Order size
-         * @param {float} [price] Price to fill order at
-         * @param {object} [params] Exchange specific params
-         * @returns An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
-        await this.loadMarkets();
-        const request = {
-            'orderId': id,
-        };
-        if (amount !== undefined) {
-            request['size'] = amount;
-        }
-        if (price !== undefined) {
-            request['limitPrice'] = price;
-        }
-        const response = await this.privatePostEditorder(this.extend(request, params));
-        const status = this.safeString(response['editStatus'], 'status');
-        this.verifyOrderActionSuccess(status, 'editOrder', ['filled']);
-        const order = this.parseOrder(response['editStatus']);
-        order['info'] = response;
-        return order;
-    }
-    async cancelOrder(id, symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#cancelOrder
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-cancel-order
-         * @description Cancel an open order on the exchange
-         * @param {string} id Order id
-         * @param {string} symbol Not used by Krakenfutures
-         * @param {object} [params] Exchange specific params
-         * @returns An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
-        await this.loadMarkets();
-        const response = await this.privatePostCancelorder(this.extend({ 'order_id': id }, params));
-        const status = this.safeString(this.safeValue(response, 'cancelStatus', {}), 'status');
-        this.verifyOrderActionSuccess(status, 'cancelOrder');
-        let order = {};
-        if ('cancelStatus' in response) {
-            order = this.parseOrder(response['cancelStatus']);
-        }
-        return this.extend({ 'info': response }, order);
-    }
-    async cancelOrders(ids, symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#cancelOrders
-         * @description cancel multiple orders
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-batch-order-management
-         * @param {string[]} ids order ids
-         * @param {string} [symbol] unified market symbol
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         *
-         * EXCHANGE SPECIFIC PARAMETERS
-         * @param {string[]} [params.clientOrderIds] max length 10 e.g. ["my_id_1","my_id_2"]
-         * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
-        await this.loadMarkets();
-        const orders = [];
-        const clientOrderIds = this.safeValue(params, 'clientOrderIds', []);
-        const clientOrderIdsLength = clientOrderIds.length;
-        if (clientOrderIdsLength > 0) {
-            for (let i = 0; i < clientOrderIds.length; i++) {
-                orders.push({ 'order': 'cancel', 'cliOrdId': clientOrderIds[i] });
-            }
-        }
-        else {
-            for (let i = 0; i < ids.length; i++) {
-                orders.push({ 'order': 'cancel', 'order_id': ids[i] });
-            }
-        }
-        const request = {
-            'batchOrder': orders,
-        };
-        const response = await this.privatePostBatchorder(this.extend(request, params));
-        // {
-        //     "result": "success",
-        //     "serverTime": "2023-10-23T16:36:51.327Z",
-        //     "batchStatus": [
-        //       {
-        //         "status": "cancelled",
-        //         "order_id": "101c2327-f12e-45f2-8445-7502b87afc0b",
-        //         "orderEvents": [
-        //           {
-        //             "uid": "101c2327-f12e-45f2-8445-7502b87afc0b",
-        //             "order": {
-        //               "orderId": "101c2327-f12e-45f2-8445-7502b87afc0b",
-        //               "cliOrdId": null,
-        //               "type": "lmt",
-        //               "symbol": "PF_LTCUSD",
-        //               "side": "buy",
-        //               "quantity": "0.10000000000",
-        //               "filled": "0E-11",
-        //               "limitPrice": "50.00000000000",
-        //               "reduceOnly": false,
-        //               "timestamp": "2023-10-20T10:29:13.005Z",
-        //               "lastUpdateTimestamp": "2023-10-20T10:29:13.005Z"
-        //             },
-        //             "type": "CANCEL"
-        //           }
-        //         ]
-        //       }
-        //     ]
-        // }
-        const batchStatus = this.safeValue(response, 'batchStatus', []);
-        return this.parseOrders(batchStatus);
-    }
-    async cancelAllOrders(symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#cancelAllOrders
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-cancel-all-orders
-         * @description Cancels all orders on the exchange, including trigger orders
-         * @param {str} symbol Unified market symbol
-         * @param {dict} [params] Exchange specific params
-         * @returns Response from exchange api
-         */
-        const request = {};
-        if (symbol !== undefined) {
-            request['symbol'] = this.marketId(symbol);
-        }
-        const response = await this.privatePostCancelallorders(this.extend(request, params));
-        return response;
-    }
-    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchOpenOrders
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-order-management-get-open-orders
-         * @description Gets all open orders, including trigger orders, for an account from the exchange api
-         * @param {string} symbol Unified market symbol
-         * @param {int} [since] Timestamp (ms) of earliest order. (Not used by kraken api but filtered internally by CCXT)
-         * @param {int} [limit] How many orders to return. (Not used by kraken api but filtered internally by CCXT)
-         * @param {object} [params] Exchange specific parameters
-         * @returns An array of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
-         */
-        await this.loadMarkets();
-        let market = undefined;
-        if (symbol !== undefined) {
-            market = this.market(symbol);
-        }
-        const response = await this.privateGetOpenorders(params);
-        const orders = this.safeValue(response, 'openOrders', []);
-        return this.parseOrders(orders, market, since, limit);
-    }
-    parseOrderType(orderType) {
-        const map = {
-            'lmt': 'limit',
-            'mkt': 'market',
-            'post': 'limit',
-            'ioc': 'market',
-        };
-        return this.safeString(map, orderType, orderType);
-    }
-    verifyOrderActionSuccess(status, method, omit = []) {
-        const errors$1 = {
-            'invalidOrderType': errors.InvalidOrder,
-            'invalidSide': errors.InvalidOrder,
-            'invalidSize': errors.InvalidOrder,
-            'invalidPrice': errors.InvalidOrder,
-            'insufficientAvailableFunds': errors.InsufficientFunds,
-            'selfFill': errors.ExchangeError,
-            'tooManySmallOrders': errors.ExchangeError,
-            'maxPositionViolation': errors.BadRequest,
-            'marketSuspended': errors.ExchangeNotAvailable,
-            'marketInactive': errors.ExchangeNotAvailable,
-            'clientOrderIdAlreadyExist': errors.DuplicateOrderId,
-            'clientOrderIdTooLong': errors.BadRequest,
-            'outsidePriceCollar': errors.InvalidOrder,
-            'postWouldExecute': errors.OrderImmediatelyFillable,
-            'iocWouldNotExecute': errors.OrderNotFillable,
-            'wouldNotReducePosition': errors.ExchangeError,
-            'orderForEditNotFound': errors.OrderNotFound,
-            'orderForEditNotAStop': errors.InvalidOrder,
-            'filled': errors.OrderNotFound,
-            'notFound': errors.OrderNotFound,
-        };
-        if ((status in errors$1) && !this.inArray(status, omit)) {
-            throw new errors$1[status](this.id + ': ' + method + ' failed due to ' + status);
-        }
-    }
-    parseOrderStatus(status) {
-        const statuses = {
-            'placed': 'open',
-            'cancelled': 'canceled',
-            'invalidOrderType': 'rejected',
-            'invalidSide': 'rejected',
-            'invalidSize': 'rejected',
-            'invalidPrice': 'rejected',
-            'insufficientAvailableFunds': 'rejected',
-            'selfFill': 'rejected',
-            'tooManySmallOrders': 'rejected',
-            'maxPositionViolation': 'rejected',
-            'marketSuspended': 'rejected',
-            'marketInactive': 'rejected',
-            'clientOrderIdAlreadyExist': 'rejected',
-            'clientOrderIdTooLong': 'rejected',
-            'outsidePriceCollar': 'rejected',
-            // Should the next two be 'expired' ?
-            'postWouldExecute': 'rejected',
-            'iocWouldNotExecute': 'rejected',
-            'wouldNotReducePosition': 'rejected',
-            'edited': 'open',
-            'orderForEditNotFound': 'rejected',
-            'orderForEditNotAStop': 'rejected',
-            'filled': 'closed',
-            'notFound': 'rejected',
-            'untouched': 'open',
-            'partiallyFilled': 'open', // the size of the order is partially but not entirely filled
-        };
-        return this.safeString(statuses, status, status);
-    }
-    parseOrder(order, market = undefined) {
-        //
-        // LIMIT
-        //
-        //    {
-        //        "order_id": "179f9af8-e45e-469d-b3e9-2fd4675cb7d0",
-        //        "status": "placed",
-        //        "receivedTime": "2019-09-05T16:33:50.734Z",
-        //        "orderEvents": [
-        //            {
-        //                "uid": "614a5298-0071-450f-83c6-0617ce8c6bc4",
-        //                "order": {
-        //                    "orderId": "179f9af8-e45e-469d-b3e9-2fd4675cb7d0",
-        //                    "cliOrdId": null,
-        //                    "type": "lmt",
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity": 10000,
-        //                    "filled": 0,
-        //                    "limitPrice": 9400,
-        //                    "reduceOnly": false,
-        //                    "timestamp": "2019-09-05T16:33:50.734Z",
-        //                    "lastUpdateTimestamp": "2019-09-05T16:33:50.734Z"
-        //                },
-        //                "reducedQuantity": null,
-        //                "reason": "WOULD_NOT_REDUCE_POSITION", // REJECTED
-        //                "type": "PLACE"
-        //            }
-        //        ]
-        //    }
-        //
-        // CONDITIONAL
-        //
-        //    {
-        //        "order_id": "1abfd3c6-af93-4b30-91cc-e4a93797f3f5",
-        //        "status": "placed",
-        //        "receivedTime": "2019-12-05T10:20:50.701Z",
-        //        "orderEvents": [
-        //            {
-        //                "orderTrigger": {
-        //                    "uid": "1abfd3c6-af93-4b30-91cc-e4a93797f3f5",
-        //                    "clientId":null,
-        //                    "type": "lmt",                                // "ioc" if stop market
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity":10,
-        //                    "limitPrice":15000,
-        //                    "triggerPrice":9500,
-        //                    "triggerSide": "trigger_below",
-        //                    "triggerSignal": "mark_price",
-        //                    "reduceOnly":false,
-        //                    "timestamp": "2019-12-05T10:20:50.701Z",
-        //                    "lastUpdateTimestamp": "2019-12-05T10:20:50.701Z"
-        //                },
-        //                "type": "PLACE"
-        //            }
-        //        ]
-        //    }
-        //
-        // EXECUTION
-        //
-        //    {
-        //        "order_id": "61ca5732-3478-42fe-8362-abbfd9465294",
-        //        "status": "placed",
-        //        "receivedTime": "2019-12-11T17:17:33.888Z",
-        //        "orderEvents": [
-        //            {
-        //                "executionId": "e1ec9f63-2338-4c44-b40a-43486c6732d7",
-        //                "price": 7244.5,
-        //                "amount": 10,
-        //                "orderPriorEdit": null,
-        //                "orderPriorExecution": {
-        //                    "orderId": "61ca5732-3478-42fe-8362-abbfd9465294",
-        //                    "cliOrdId": null,
-        //                    "type": "lmt",
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity": 10,
-        //                    "filled": 0,
-        //                    "limitPrice": 7500,
-        //                    "reduceOnly": false,
-        //                    "timestamp": "2019-12-11T17:17:33.888Z",
-        //                    "lastUpdateTimestamp": "2019-12-11T17:17:33.888Z"
-        //                },
-        //                "takerReducedQuantity": null,
-        //                "type": "EXECUTION"
-        //            }
-        //        ]
-        //    }
-        //
-        // EDIT ORDER
-        //
-        //    {
-        //        "status": "edited",
-        //        "orderId": "022774bc-2c4a-4f26-9317-436c8d85746d",
-        //        "receivedTime": "2019-09-05T16:47:47.521Z",
-        //        "orderEvents": [
-        //            {
-        //                "old": {
-        //                    "orderId": "022774bc-2c4a-4f26-9317-436c8d85746d",
-        //                    "cliOrdId":null,
-        //                    "type": "lmt",
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity":1000,
-        //                    "filled":0,
-        //                    "limitPrice":9400.0,
-        //                    "reduceOnly":false,
-        //                    "timestamp": "2019-09-05T16:41:35.173Z",
-        //                    "lastUpdateTimestamp": "2019-09-05T16:41:35.173Z"
-        //                },
-        //                "new": {
-        //                    "orderId": "022774bc-2c4a-4f26-9317-436c8d85746d",
-        //                    "cliOrdId": null,
-        //                    "type": "lmt",
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity": 1501,
-        //                    "filled": 0,
-        //                    "limitPrice": 7200,
-        //                    "reduceOnly": false,
-        //                    "timestamp": "2019-09-05T16:41:35.173Z",
-        //                    "lastUpdateTimestamp": "2019-09-05T16:47:47.519Z"
-        //                },
-        //                "reducedQuantity": null,
-        //                "type": "EDIT"
-        //            }
-        //        ]
-        //    }
-        //
-        // CANCEL ORDER
-        //
-        //    {
-        //        "status": "cancelled",
-        //        "orderEvents": [
-        //            {
-        //                "uid": "85c40002-3f20-4e87-9302-262626c3531b",
-        //                "order": {
-        //                    "orderId": "85c40002-3f20-4e87-9302-262626c3531b",
-        //                    "cliOrdId": null,
-        //                    "type": "lmt",
-        //                    "symbol": "pi_xbtusd",
-        //                    "side": "buy",
-        //                    "quantity": 1000,
-        //                    "filled": 0,
-        //                    "limitPrice": 10144,
-        //                    "stopPrice": null,
-        //                    "reduceOnly": false,
-        //                    "timestamp": "2019-08-01T15:26:27.790Z"
-        //                },
-        //                "type": "CANCEL"
-        //            }
-        //        ]
-        //    }
-        //
-        // FETCH OPEN ORDERS
-        //
-        //    {
-        //        "order_id": "59302619-41d2-4f0b-941f-7e7914760ad3",
-        //        "symbol": "pi_xbtusd",
-        //        "side": "sell",
-        //        "orderType": "lmt",
-        //        "limitPrice": 10640,
-        //        "unfilledSize": 304,
-        //        "receivedTime": "2019-09-05T17:01:17.410Z",
-        //        "status": "untouched",
-        //        "filledSize": 0,
-        //        "reduceOnly": true,
-        //        "lastUpdateTime": "2019-09-05T17:01:17.410Z"
-        //    }
-        //
-        // createOrders error
-        //    {
-        //       "status": "requiredArgumentMissing",
-        //       "orderEvents": []
-        //    }
-        //
-        const orderEvents = this.safeValue(order, 'orderEvents', []);
-        const errorStatus = this.safeString(order, 'status');
-        const orderEventsLength = orderEvents.length;
-        if (('orderEvents' in order) && (errorStatus !== undefined) && (orderEventsLength === 0)) {
-            // creteOrders error response
-            return this.safeOrder({ 'info': order, 'status': 'rejected' });
-        }
-        let details = undefined;
-        let isPrior = false;
-        let fixed = false;
-        let statusId = undefined;
-        let price = undefined;
-        let trades = [];
-        if (orderEventsLength) {
-            const executions = [];
-            for (let i = 0; i < orderEvents.length; i++) {
-                const item = orderEvents[i];
-                if (this.safeString(item, 'type') === 'EXECUTION') {
-                    executions.push(item);
-                }
-                // Final order (after placement / editing / execution / canceling)
-                const orderTrigger = this.safeValue(item, 'orderTrigger');
-                details = this.safeValue2(item, 'new', 'order', orderTrigger);
-                if (details !== undefined) {
-                    isPrior = false;
-                    fixed = true;
-                }
-                else if (!fixed) {
-                    const orderPriorExecution = this.safeValue(item, 'orderPriorExecution');
-                    details = this.safeValue2(item, 'orderPriorExecution', 'orderPriorEdit');
-                    price = this.safeString(orderPriorExecution, 'limitPrice');
-                    if (details !== undefined) {
-                        isPrior = true;
-                    }
-                }
-            }
-            trades = this.parseTrades(executions);
-            statusId = this.safeString(order, 'status');
-        }
-        if (details === undefined) {
-            details = order;
-        }
-        if (statusId === undefined) {
-            statusId = this.safeString(details, 'status');
-        }
-        // This may be incorrectly marked as "open" if only execution report is given,
-        // but will be fixed below
-        let status = this.parseOrderStatus(statusId);
-        let isClosed = this.inArray(status, ['canceled', 'rejected', 'closed']);
-        const marketId = this.safeString(details, 'symbol');
-        market = this.safeMarket(marketId, market);
-        const timestamp = this.parse8601(this.safeString2(details, 'timestamp', 'receivedTime'));
-        const lastUpdateTimestamp = this.parse8601(this.safeString(details, 'lastUpdateTime'));
-        if (price === undefined) {
-            price = this.safeString(details, 'limitPrice');
-        }
-        let amount = this.safeString(details, 'quantity');
-        let filled = this.safeString2(details, 'filledSize', 'filled', '0.0');
-        let remaining = this.safeString(details, 'unfilledSize');
-        let average = undefined;
-        let filled2 = '0.0';
-        if (trades.length) {
-            let vwapSum = '0.0';
-            for (let i = 0; i < trades.length; i++) {
-                const trade = trades[i];
-                const tradeAmount = this.safeString(trade, 'amount');
-                const tradePrice = this.safeString(trade, 'price');
-                filled2 = Precise["default"].stringAdd(filled2, tradeAmount);
-                vwapSum = Precise["default"].stringAdd(vwapSum, Precise["default"].stringMul(tradeAmount, tradePrice));
-            }
-            average = Precise["default"].stringDiv(vwapSum, filled2);
-            if ((amount !== undefined) && (!isClosed) && isPrior && Precise["default"].stringGe(filled2, amount)) {
-                status = 'closed';
-                isClosed = true;
-            }
-            if (isPrior) {
-                filled = Precise["default"].stringAdd(filled, filled2);
-            }
-            else {
-                filled = Precise["default"].stringMax(filled, filled2);
-            }
-        }
-        if (remaining === undefined) {
-            if (isPrior) {
-                if (amount !== undefined) {
-                    // remaining amount before execution minus executed amount
-                    remaining = Precise["default"].stringSub(amount, filled2);
-                }
-            }
-            else {
-                remaining = amount;
-            }
-        }
-        // if fetchOpenOrders are parsed
-        if ((amount === undefined) && (!isPrior) && (remaining !== undefined)) {
-            amount = Precise["default"].stringAdd(filled, remaining);
-        }
-        let cost = undefined;
-        if ((filled !== undefined) && (market !== undefined)) {
-            const whichPrice = (average !== undefined) ? average : price;
-            if (whichPrice !== undefined) {
-                if (market['linear']) {
-                    cost = Precise["default"].stringMul(filled, whichPrice); // in quote
-                }
-                else {
-                    cost = Precise["default"].stringDiv(filled, whichPrice); // in base
-                }
-            }
-        }
-        let id = this.safeString2(order, 'order_id', 'orderId');
-        if (id === undefined) {
-            id = this.safeString2(details, 'orderId', 'uid');
-        }
-        const type = this.safeStringLower2(details, 'type', 'orderType');
-        let timeInForce = 'gtc';
-        if (type === 'ioc' || this.parseOrderType(type) === 'market') {
-            timeInForce = 'ioc';
-        }
-        return this.safeOrder({
-            'info': order,
-            'id': id,
-            'clientOrderId': this.safeStringN(details, ['clientOrderId', 'clientId', 'cliOrdId']),
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'lastTradeTimestamp': undefined,
-            'lastUpdateTimestamp': lastUpdateTimestamp,
-            'symbol': this.safeString(market, 'symbol'),
-            'type': this.parseOrderType(type),
-            'timeInForce': timeInForce,
-            'postOnly': type === 'post',
-            'reduceOnly': this.safeValue(details, 'reduceOnly'),
-            'side': this.safeString(details, 'side'),
-            'price': price,
-            'stopPrice': this.safeString(details, 'triggerPrice'),
-            'triggerPrice': this.safeString(details, 'triggerPrice'),
-            'amount': amount,
-            'cost': cost,
-            'average': average,
-            'filled': filled,
-            'remaining': remaining,
-            'status': status,
-            'fee': undefined,
-            'fees': undefined,
-            'trades': trades,
-        });
-    }
-    async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchMyTrades
-         * @description fetch all trades made by the user
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-historical-data-get-your-fills
-         * @param {string} symbol unified market symbol
-         * @param {int} [since] *not used by the  api* the earliest time in ms to fetch trades for
-         * @param {int} [limit] the maximum number of trades structures to retrieve
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {int} [params.until] the latest time in ms to fetch entries for
-         * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
-         */
-        await this.loadMarkets();
-        let market = undefined;
-        if (symbol !== undefined) {
-            market = this.market(symbol);
-        }
-        const response = await this.privateGetFills(params);
-        //
-        //    {
-        //        "result": "success",
-        //        "serverTime": "2016-02-25T09:45:53.818Z",
-        //        "fills": [
-        //            {
-        //                "fillTime": "2016-02-25T09:47:01.000Z",
-        //                "order_id": "c18f0c17-9971-40e6-8e5b-10df05d422f0",
-        //                "fill_id": "522d4e08-96e7-4b44-9694-bfaea8fe215e",
-        //                "cliOrdId": "d427f920-ec55-4c18-ba95-5fe241513b30", // EXTRA
-        //                "symbol": "fi_xbtusd_180615",
-        //                "side": "buy",
-        //                "size": 2000,
-        //                "price": 4255,
-        //                "fillType": "maker"
-        //            },
-        //            ...
-        //        ]
-        //    }
-        //
-        return this.parseTrades(response['fills'], market, since, limit);
-    }
-    async fetchBalance(params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchBalance
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-account-information-get-wallets
-         * @description Fetch the balance for a sub-account, all sub-account balances are inside 'info' in the response
-         * @param {object} [params] Exchange specific parameters
-         * @param {string} [params.type] The sub-account type to query the balance of, possible values include 'flex', 'cash'/'main'/'funding', or a market symbol * defaults to 'flex' *
-         * @param {string} [params.symbol] A unified market symbol, when assigned the balance for a trading market that matches the symbol is returned
-         * @returns A [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
-         */
-        await this.loadMarkets();
-        let type = this.safeString2(params, 'type', 'account');
-        let symbol = this.safeString(params, 'symbol');
-        params = this.omit(params, ['type', 'account', 'symbol']);
-        const response = await this.privateGetAccounts(params);
-        //
-        //    {
-        //        "result": "success",
-        //        "accounts": {
-        //            "fi_xbtusd": {
-        //                "auxiliary": { usd: "0", pv: '0.0', pnl: '0.0', af: '0.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { xbt: "0.0" },
-        //                "currency": "xbt",
-        //                "type": "marginAccount"
-        //            },
-        //            "cash": {
-        //                "balances": {
-        //                    "eur": "0.0",
-        //                    "gbp": "0.0",
-        //                    "bch": "0.0",
-        //                    "xrp": "2.20188538338",
-        //                    "usd": "0.0",
-        //                    "eth": "0.0",
-        //                    "usdt": "0.0",
-        //                    "ltc": "0.0",
-        //                    "usdc": "0.0",
-        //                    "xbt": "0.0"
-        //                },
-        //                "type": "cashAccount"
-        //            },
-        //            "fv_xrpxbt": {
-        //                "auxiliary": { usd: "0", pv: '0.0', pnl: '0.0', af: '0.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { xbt: "0.0" },
-        //                "currency": "xbt",
-        //                "type": "marginAccount"
-        //            },
-        //            "fi_xrpusd": {
-        //                "auxiliary": { usd: "0", pv: '11.0', pnl: '0.0', af: '11.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { xrp: "11.0" },
-        //                "currency": "xrp",
-        //                "type": "marginAccount"
-        //            },
-        //            "fi_ethusd": {
-        //                "auxiliary": { usd: "0", pv: '0.0', pnl: '0.0', af: '0.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { eth: "0.0" },
-        //                "currency": "eth",
-        //                "type": "marginAccount"
-        //            },
-        //            "fi_ltcusd": {
-        //                "auxiliary": { usd: "0", pv: '0.0', pnl: '0.0', af: '0.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { ltc: "0.0" },
-        //                "currency": "ltc",
-        //                "type": "marginAccount"
-        //            },
-        //            "fi_bchusd": {
-        //                "auxiliary": { usd: "0", pv: '0.0', pnl: '0.0', af: '0.0', funding: "0.0" },
-        //                "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //                "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //                "balances": { bch: "0.0" },
-        //                "currency": "bch",
-        //                "type": "marginAccount"
-        //            },
-        //            "flex": {
-        //                "currencies": {},
-        //                "initialMargin": "0.0",
-        //                "initialMarginWithOrders": "0.0",
-        //                "maintenanceMargin": "0.0",
-        //                "balanceValue": "0.0",
-        //                "portfolioValue": "0.0",
-        //                "collateralValue": "0.0",
-        //                "pnl": "0.0",
-        //                "unrealizedFunding": "0.0",
-        //                "totalUnrealized": "0.0",
-        //                "totalUnrealizedAsMargin": "0.0",
-        //                "availableMargin": "0.0",
-        //                "marginEquity": "0.0",
-        //                "type": "multiCollateralMarginAccount"
-        //            }
-        //        },
-        //        "serverTime": "2022-04-12T07:48:07.475Z"
-        //    }
-        //
-        const datetime = this.safeString(response, 'serverTime');
-        if (type === 'marginAccount' || type === 'margin') {
-            if (symbol === undefined) {
-                throw new errors.ArgumentsRequired(this.id + ' fetchBalance requires symbol argument for margin accounts');
-            }
-            type = symbol;
-        }
-        if (type === undefined) {
-            type = (symbol === undefined) ? 'flex' : symbol;
-        }
-        const accountName = this.parseAccount(type);
-        const accounts = this.safeValue(response, 'accounts');
-        const account = this.safeValue(accounts, accountName);
-        if (account === undefined) {
-            type = (type === undefined) ? '' : type;
-            symbol = (symbol === undefined) ? '' : symbol;
-            throw new errors.BadRequest(this.id + ' fetchBalance has no account for ' + type);
-        }
-        const balance = this.parseBalance(account);
-        balance['info'] = response;
-        balance['timestamp'] = this.parse8601(datetime);
-        balance['datetime'] = datetime;
-        return balance;
-    }
-    parseBalance(response) {
-        //
-        // cashAccount
-        //
-        //    {
-        //        "balances": {
-        //            "eur": "0.0",
-        //            "gbp": "0.0",
-        //            "bch": "0.0",
-        //            "xrp": "2.20188538338",
-        //            "usd": "0.0",
-        //            "eth": "0.0",
-        //            "usdt": "0.0",
-        //            "ltc": "0.0",
-        //            "usdc": "0.0",
-        //            "xbt": "0.0"
-        //        },
-        //        "type": "cashAccount"
-        //    }
-        //
-        // marginAccount e,g, fi_xrpusd
-        //
-        //    {
-        //        "auxiliary": {
-        //            "usd": "0",
-        //            "pv": "11.0",
-        //            "pnl": "0.0",
-        //            "af": "11.0",
-        //            "funding": "0.0"
-        //        },
-        //        "marginRequirements": { im: '0.0', mm: '0.0', lt: '0.0', tt: "0.0" },
-        //        "triggerEstimates": { im: '0', mm: '0', lt: "0", tt: "0" },
-        //        "balances": { xrp: "11.0" },
-        //        "currency": "xrp",
-        //        "type": "marginAccount"
-        //    }
-        //
-        // flex/multiCollateralMarginAccount
-        //
-        //    {
-        //       "currencies": {
-        //            "USDT": {
-        //                "quantity": "1",
-        //                "value": "1.0001",
-        //                "collateral": "0.9477197625",
-        //                "available": "1.0"
-        //             }
-        //       },
-        //       "initialMargin": "0.0",
-        //       "initialMarginWithOrders": "0.0",
-        //       "maintenanceMargin": "0.0",
-        //       "balanceValue": "1.0",
-        //       "portfolioValue": "1.0",
-        //       "collateralValue": "0.95",
-        //       "pnl": "0.0",
-        //       "unrealizedFunding": "0.0",
-        //       "totalUnrealized": "0.0",
-        //       "totalUnrealizedAsMargin": "0.0",
-        //       "availableMargin": "0.95",
-        //       "marginEquity": "0.95",
-        //       "type": "multiCollateralMarginAccount"
-        //    }
-        //
-        const accountType = this.safeString2(response, 'accountType', 'type');
-        const isFlex = (accountType === 'multiCollateralMarginAccount');
-        const isCash = (accountType === 'cashAccount');
-        const balances = this.safeValue2(response, 'balances', 'currencies', {});
-        const result = {};
-        const currencyIds = Object.keys(balances);
-        for (let i = 0; i < currencyIds.length; i++) {
-            const currencyId = currencyIds[i];
-            const balance = balances[currencyId];
-            const code = this.safeCurrencyCode(currencyId);
-            const splitCode = code.split('_');
-            const codeLength = splitCode.length;
-            if (codeLength > 1) {
-                continue; // Removes contract codes like PI_XRPUSD
-            }
-            const account = this.account();
-            if (isFlex) {
-                account['total'] = this.safeString(balance, 'quantity');
-                account['free'] = this.safeString(balance, 'available');
-            }
-            else if (isCash) {
-                account['used'] = '0.0';
-                account['total'] = balance;
-            }
-            else {
-                const auxiliary = this.safeValue(response, 'auxiliary');
-                account['free'] = this.safeString(auxiliary, 'af');
-                account['total'] = this.safeString(auxiliary, 'pv');
-            }
-            result[code] = account;
-        }
-        return this.safeBalance(result);
-    }
-    async fetchFundingRates(symbols = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchFundingRates
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-market-data-get-tickers
-         * @description fetch the current funding rates
-         * @param {string[]} symbols unified market symbols
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {Order[]} an array of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
-         */
-        await this.loadMarkets();
-        const marketIds = this.marketIds(symbols);
-        const response = await this.publicGetTickers(params);
-        const tickers = this.safeValue(response, 'tickers');
-        const fundingRates = [];
-        for (let i = 0; i < tickers.length; i++) {
-            const entry = tickers[i];
-            const entry_symbol = this.safeValue(entry, 'symbol');
-            if (marketIds !== undefined) {
-                if (!this.inArray(entry_symbol, marketIds)) {
-                    continue;
-                }
-            }
-            const market = this.safeMarket(entry_symbol);
-            const parsed = this.parseFundingRate(entry, market);
-            fundingRates.push(parsed);
-        }
-        return this.indexBy(fundingRates, 'symbol');
-    }
-    parseFundingRate(ticker, market = undefined) {
-        //
-        // {"ask": 26.283,
-        //  "askSize": 4.6,
-        //  "bid": 26.201,
-        //  "bidSize": 190,
-        //  "fundingRate": -0.000944642727438883,
-        //  "fundingRatePrediction": -0.000872671532340275,
-        //  "indexPrice": 26.253,
-        //  "last": 26.3,
-        //  "lastSize": 0.1,
-        //  "lastTime": "2023-06-11T18:55:28.958Z",
-        //  "markPrice": 26.239,
-        //  "open24h": 26.3,
-        //  "openInterest": 641.1,
-        //  "pair": "COMP:USD",
-        //  "postOnly": False,
-        //  "suspended": False,
-        //  "symbol": "pf_compusd",
-        //  "tag": "perpetual",
-        //  "vol24h": 0.1,
-        //  "volumeQuote": 2.63}
-        //
-        const fundingRateMultiplier = '8'; // https://support.kraken.com/hc/en-us/articles/9618146737172-Perpetual-Contracts-Funding-Rate-Method-Prior-to-September-29-2022
-        const marketId = this.safeString(ticker, 'symbol');
-        const symbol = this.symbol(marketId);
-        const timestamp = this.parse8601(this.safeString(ticker, 'lastTime'));
-        const indexPrice = this.safeNumber(ticker, 'indexPrice');
-        const markPriceString = this.safeString(ticker, 'markPrice');
-        const markPrice = this.parseNumber(markPriceString);
-        const fundingRateString = this.safeString(ticker, 'fundingRate');
-        const fundingRateResult = Precise["default"].stringDiv(Precise["default"].stringMul(fundingRateString, fundingRateMultiplier), markPriceString);
-        const fundingRate = this.parseNumber(fundingRateResult);
-        const nextFundingRateString = this.safeString(ticker, 'fundingRatePrediction');
-        const nextFundingRateResult = Precise["default"].stringDiv(Precise["default"].stringMul(nextFundingRateString, fundingRateMultiplier), markPriceString);
-        const nextFundingRate = this.parseNumber(nextFundingRateResult);
-        return {
-            'info': ticker,
-            'symbol': symbol,
-            'markPrice': markPrice,
-            'indexPrice': indexPrice,
-            'interestRate': undefined,
-            'estimatedSettlePrice': undefined,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'fundingRate': fundingRate,
-            'fundingTimestamp': undefined,
-            'fundingDatetime': undefined,
-            'nextFundingRate': nextFundingRate,
-            'nextFundingTimestamp': undefined,
-            'nextFundingDatetime': undefined,
-            'previousFundingRate': undefined,
-            'previousFundingTimestamp': undefined,
-            'previousFundingDatetime': undefined,
-        };
-    }
-    async fetchFundingRateHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchFundingRateHistory
-         * @description fetches historical funding rate prices
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-historical-funding-rates-historical-funding-rates
-         * @param {string} symbol unified symbol of the market to fetch the funding rate history for
-         * @param {int} [since] timestamp in ms of the earliest funding rate to fetch
-         * @param {int} [limit] the maximum amount of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure} to fetch
-         * @param {object} [params] extra parameters specific to the api endpoint
-         * @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure}
-         */
-        if (symbol === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' fetchFundingRateHistory() requires a symbol argument');
-        }
-        await this.loadMarkets();
-        const market = this.market(symbol);
-        if (!market['swap']) {
-            throw new errors.BadRequest(this.id + ' fetchFundingRateHistory() supports swap contracts only');
-        }
-        const request = {
-            'symbol': market['id'].toUpperCase(),
-        };
-        const response = await this.publicGetHistoricalfundingrates(this.extend(request, params));
-        //
-        //    {
-        //        "rates": [
-        //          {
-        //            "timestamp": '2018-08-31T16:00:00.000Z',
-        //            "fundingRate": '2.18900669884E-7',
-        //            "relativeFundingRate": '0.000060779960000000'
-        //          },
-        //          ...
-        //        ]
-        //    }
-        //
-        const rates = this.safeValue(response, 'rates');
-        const result = [];
-        for (let i = 0; i < rates.length; i++) {
-            const item = rates[i];
-            const datetime = this.safeString(item, 'timestamp');
-            result.push({
-                'info': item,
-                'symbol': symbol,
-                'fundingRate': this.safeNumber(item, 'relativeFundingRate'),
-                'timestamp': this.parse8601(datetime),
-                'datetime': datetime,
-            });
-        }
-        const sorted = this.sortBy(result, 'timestamp');
-        return this.filterBySymbolSinceLimit(sorted, symbol, since, limit);
-    }
-    async fetchPositions(symbols = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchPositions
-         * @see https://docs.futures.kraken.com/#websocket-api-private-feeds-open-positions
-         * @description Fetches current contract trading positions
-         * @param {string[]} symbols List of unified symbols
-         * @param {object} [params] Not used by krakenfutures
-         * @returns Parsed exchange response for positions
-         */
-        await this.loadMarkets();
-        const request = {};
-        const response = await this.privateGetOpenpositions(request);
-        //
-        //    {
-        //        "result": "success",
-        //        "openPositions": [
-        //            {
-        //                "side": "long",
-        //                "symbol": "pi_xrpusd",
-        //                "price": "0.7533",
-        //                "fillTime": "2022-03-03T22:51:16.566Z",
-        //                "size": "230",
-        //                "unrealizedFunding": "-0.001878596918214635"
-        //            }
-        //        ],
-        //        "serverTime": "2022-03-03T22:51:16.566Z"
-        //    }
-        //
-        const result = this.parsePositions(response);
-        return this.filterByArrayPositions(result, 'symbol', symbols, false);
-    }
-    parsePositions(response, symbols = undefined, params = {}) {
-        const result = [];
-        const positions = this.safeValue(response, 'openPositions');
-        for (let i = 0; i < positions.length; i++) {
-            const position = this.parsePosition(positions[i]);
-            result.push(position);
-        }
-        return result;
-    }
-    parsePosition(position, market = undefined) {
-        // cross
-        //    {
-        //        "side": "long",
-        //        "symbol": "pi_xrpusd",
-        //        "price": "0.7533",
-        //        "fillTime": "2022-03-03T22:51:16.566Z",
-        //        "size": "230",
-        //        "unrealizedFunding": "-0.001878596918214635"
-        //    }
-        //
-        // isolated
-        //    {
-        //        "side":"long",
-        //        "symbol":"pf_ftmusd",
-        //        "price":"0.4921",
-        //        "fillTime":"2023-02-22T11:37:16.685Z",
-        //        "size":"1",
-        //        "unrealizedFunding":"-8.155240068885155E-8",
-        //        "pnlCurrency":"USD",
-        //        "maxFixedLeverage":"1.0"
-        //    }
-        //
-        const leverage = this.safeNumber(position, 'maxFixedLeverage');
-        let marginType = 'cross';
-        if (leverage !== undefined) {
-            marginType = 'isolated';
-        }
-        const datetime = this.safeString(position, 'fillTime');
-        const marketId = this.safeString(position, 'symbol');
-        market = this.safeMarket(marketId, market);
-        return {
-            'info': position,
-            'symbol': market['symbol'],
-            'timestamp': this.parse8601(datetime),
-            'datetime': datetime,
-            'initialMargin': undefined,
-            'initialMarginPercentage': undefined,
-            'maintenanceMargin': undefined,
-            'maintenanceMarginPercentage': undefined,
-            'entryPrice': this.safeNumber(position, 'price'),
-            'notional': undefined,
-            'leverage': leverage,
-            'unrealizedPnl': undefined,
-            'contracts': this.safeNumber(position, 'size'),
-            'contractSize': this.safeNumber(market, 'contractSize'),
-            'marginRatio': undefined,
-            'liquidationPrice': undefined,
-            'markPrice': undefined,
-            'collateral': undefined,
-            'marginType': marginType,
-            'side': this.safeString(position, 'side'),
-            'percentage': undefined,
-        };
-    }
-    async fetchLeverageTiers(symbols = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchLeverageTiers
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-instrument-details-get-instruments
-         * @description retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes
-         * @param {string[]|undefined} symbols list of unified market symbols
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} a dictionary of [leverage tiers structures]{@link https://docs.ccxt.com/#/?id=leverage-tiers-structure}, indexed by market symbols
-         */
-        await this.loadMarkets();
-        const response = await this.publicGetInstruments(params);
-        //
-        //    {
-        //        "result": "success",
-        //        "instruments": [
-        //            {
-        //                "symbol": "fi_ethusd_180928",
-        //                "type": "futures_inverse",  // futures_vanilla  // spot index
-        //                "underlying": "rr_ethusd",
-        //                "lastTradingTime": "2018-09-28T15:00:00.000Z",
-        //                "tickSize": 0.1,
-        //                "contractSize": 1,
-        //                "tradeable": true,
-        //                "marginLevels": [
-        //                    {
-        //                        "contracts":0,
-        //                        "initialMargin":0.02,
-        //                        "maintenanceMargin":0.01
-        //                    },
-        //                    {
-        //                        "contracts":250000,
-        //                        "initialMargin":0.04,
-        //                        "maintenanceMargin":0.02
-        //                    },
-        //                    ...
-        //                ],
-        //                "isin": "GB00JVMLMP88",
-        //                "retailMarginLevels": [
-        //                    {
-        //                        "contracts": 0,
-        //                        "initialMargin": 0.5,
-        //                        "maintenanceMargin": 0.25
-        //                    }
-        //                ],
-        //                "tags": [],
-        //            },
-        //            {
-        //                "symbol": "in_xbtusd",
-        //                "type": "spot index",
-        //                "tradeable":false
-        //            }
-        //        ]
-        //        "serverTime": "2018-07-19T11:32:39.433Z"
-        //    }
-        //
-        const data = this.safeValue(response, 'instruments');
-        return this.parseLeverageTiers(data, symbols, 'symbol');
-    }
-    parseMarketLeverageTiers(info, market = undefined) {
-        /**
-         * @method
-         * @ignore
-         * @param info Exchange market response for 1 market
-         * @param market CCXT market
-         */
-        //
-        //    {
-        //        "symbol": "fi_ethusd_180928",
-        //        "type": "futures_inverse",  // futures_vanilla  // spot index
-        //        "underlying": "rr_ethusd",
-        //        "lastTradingTime": "2018-09-28T15:00:00.000Z",
-        //        "tickSize": 0.1,
-        //        "contractSize": 1,
-        //        "tradeable": true,
-        //        "marginLevels": [
-        //            {
-        //                "contracts":0,
-        //                "initialMargin":0.02,
-        //                "maintenanceMargin":0.01
-        //            },
-        //            {
-        //                "contracts":250000,
-        //                "initialMargin":0.04,
-        //                "maintenanceMargin":0.02
-        //            },
-        //            ...
-        //        ],
-        //        "isin": "GB00JVMLMP88",
-        //        "retailMarginLevels": [
-        //            {
-        //                "contracts": 0,
-        //                "initialMargin": 0.5,
-        //                "maintenanceMargin": 0.25
-        //            }
-        //        ],
-        //        "tags": [],
-        //    }
-        //
-        const marginLevels = this.safeValue(info, 'marginLevels');
-        const id = this.safeString(info, 'symbol');
-        market = this.safeMarket(id, market);
-        const tiers = [];
-        for (let i = 0; i < marginLevels.length; i++) {
-            const tier = marginLevels[i];
-            const initialMargin = this.safeString(tier, 'initialMargin');
-            const notionalFloor = this.safeNumber(tier, 'contracts');
-            if (i !== 0) {
-                const tiersLength = tiers.length;
-                const previousTier = tiers[tiersLength - 1];
-                previousTier['notionalCap'] = notionalFloor;
-            }
-            tiers.push({
-                'tier': this.sum(i, 1),
-                'currency': market['quote'],
-                'notionalFloor': notionalFloor,
-                'notionalCap': undefined,
-                'maintenanceMarginRate': this.safeNumber(tier, 'maintenanceMargin'),
-                'maxLeverage': this.parseNumber(Precise["default"].stringDiv('1', initialMargin)),
-                'info': tier,
-            });
-        }
-        return tiers;
-    }
-    parseTransfer(transfer, currency = undefined) {
-        //
-        // transfer
-        //
-        //    {
-        //        "result": "success",
-        //        "serverTime": "2022-04-12T01:22:53.420Z"
-        //    }
-        //
-        const datetime = this.safeString(transfer, 'serverTime');
-        return {
-            'info': transfer,
-            'id': undefined,
-            'timestamp': this.parse8601(datetime),
-            'datetime': datetime,
-            'currency': this.safeString(currency, 'code'),
-            'amount': undefined,
-            'fromAccount': undefined,
-            'toAccount': undefined,
-            'status': this.safeString(transfer, 'result'),
-        };
-    }
-    parseAccount(account) {
-        const accountByType = {
-            'main': 'cash',
-            'funding': 'cash',
-            'future': 'cash',
-            'futures': 'cash',
-            'cashAccount': 'cash',
-            'multiCollateralMarginAccount': 'flex',
-            'multiCollateral': 'flex',
-            'multiCollateralMargin': 'flex',
-        };
-        if (account in accountByType) {
-            return accountByType[account];
-        }
-        else if (account in this.markets) {
-            const market = this.market(account);
-            const marketId = market['id'];
-            const splitId = marketId.split('_');
-            if (market['inverse']) {
-                return 'fi_' + this.safeString(splitId, 1);
-            }
-            else {
-                return 'fv_' + this.safeString(splitId, 1);
-            }
-        }
-        else {
-            return account;
-        }
-    }
-    async transferOut(code, amount, params = {}) {
-        /**
-         * @description transfer from futures wallet to spot wallet
-         * @param {str} code Unified currency code
-         * @param {float} amount Size of the transfer
-         * @param {dict} [params] Exchange specific parameters
-         * @returns a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
-         */
-        return await this.transfer(code, amount, 'future', 'spot', params);
-    }
-    async transfer(code, amount, fromAccount, toAccount, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#transfer
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-transfers-initiate-wallet-transfer
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-transfers-initiate-withdrawal-to-spot-wallet
-         * @description transfers currencies between sub-accounts
-         * @param {string} code Unified currency code
-         * @param {float} amount Size of the transfer
-         * @param {string} fromAccount 'main'/'funding'/'future', 'flex', or a unified market symbol
-         * @param {string} toAccount 'main'/'funding', 'flex', 'spot' or a unified market symbol
-         * @param {object} [params] Exchange specific parameters
-         * @returns a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
-         */
-        await this.loadMarkets();
-        const currency = this.currency(code);
-        if (fromAccount === 'spot') {
-            throw new errors.BadRequest(this.id + ' transfer does not yet support transfers from spot');
-        }
-        const request = {
-            'amount': amount,
-        };
-        let response = undefined;
-        if (toAccount === 'spot') {
-            if (this.parseAccount(fromAccount) !== 'cash') {
-                throw new errors.BadRequest(this.id + ' transfer cannot transfer from ' + fromAccount + ' to ' + toAccount);
-            }
-            request['currency'] = currency['id'];
-            response = await this.privatePostWithdrawal(this.extend(request, params));
-        }
-        else {
-            request['fromAccount'] = this.parseAccount(fromAccount);
-            request['toAccount'] = this.parseAccount(toAccount);
-            request['unit'] = currency['id'];
-            response = await this.privatePostTransfer(this.extend(request, params));
-        }
-        //
-        //    {
-        //        "result": "success",
-        //        "serverTime": "2022-04-12T01:22:53.420Z"
-        //    }
-        //
-        const transfer = this.parseTransfer(response, currency);
-        return this.extend(transfer, {
-            'amount': amount,
-            'fromAccount': fromAccount,
-            'toAccount': toAccount,
-        });
-    }
-    async setLeverage(leverage, symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#setLeverage
-         * @description set the level of leverage for a market
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-multi-collateral-set-the-leverage-setting-for-a-market
-         * @param {float} leverage the rate of leverage
-         * @param {string} symbol unified market symbol
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} response from the exchange
-         */
-        if (symbol === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' setLeverage() requires a symbol argument');
-        }
-        await this.loadMarkets();
-        const request = {
-            'maxLeverage': leverage,
-            'symbol': this.marketId(symbol).toUpperCase(),
-        };
-        //
-        // { result: "success", serverTime: "2023-08-01T09:40:32.345Z" }
-        //
-        return await this.privatePutLeveragepreferences(this.extend(request, params));
-    }
-    async fetchLeverage(symbol = undefined, params = {}) {
-        /**
-         * @method
-         * @name krakenfutures#fetchLeverage
-         * @description fetch the set leverage for a market
-         * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-multi-collateral-get-the-leverage-setting-for-a-market
-         * @param {string} symbol unified market symbol
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
-         */
-        if (symbol === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' fetchLeverage() requires a symbol argument');
-        }
-        await this.loadMarkets();
-        const request = {
-            'symbol': this.marketId(symbol).toUpperCase(),
-        };
-        //
-        //   {
-        //       "result": "success",
-        //       "serverTime": "2023-08-01T09:54:08.900Z",
-        //       "leveragePreferences": [ { symbol: "PF_LTCUSD", maxLeverage: "5.00" } ]
-        //   }
-        //
-        return await this.privateGetLeveragepreferences(this.extend(request, params));
-    }
-    handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
-        if (response === undefined) {
-            return undefined;
-        }
-        if (code === 429) {
-            throw new errors.DDoSProtection(this.id + ' ' + body);
-        }
-        const errors$1 = this.safeValue(response, 'errors');
-        const firstError = this.safeValue(errors$1, 0);
-        const firtErrorMessage = this.safeString(firstError, 'message');
-        const message = this.safeString(response, 'error', firtErrorMessage);
-        if (message === undefined) {
-            return undefined;
-        }
-        const feedback = this.id + ' ' + body;
-        this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
-        this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
-        if (code === 400) {
-            throw new errors.BadRequest(feedback);
-        }
-        throw new errors.ExchangeError(feedback); // unknown message
-    }
-    sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
-        const apiVersions = this.safeValue(this.options['versions'], api, {});
-        const methodVersions = this.safeValue(apiVersions, method, {});
-        const defaultVersion = this.safeString(methodVersions, path, this.version);
-        const version = this.safeString(params, 'version', defaultVersion);
-        params = this.omit(params, 'version');
-        const apiAccess = this.safeValue(this.options['access'], api, {});
-        const methodAccess = this.safeValue(apiAccess, method, {});
-        const access = this.safeString(methodAccess, path, 'public');
-        const endpoint = version + '/' + this.implodeParams(path, params);
-        params = this.omit(params, this.extractParams(path));
-        let query = endpoint;
-        let postData = '';
-        if (path === 'batchorder') {
-            postData = 'json=' + this.json(params);
-            body = postData;
-        }
-        else if (Object.keys(params).length) {
-            postData = this.urlencode(params);
-            query += '?' + postData;
-        }
-        const url = this.urls['api'][api] + query;
-        if (api === 'private' || access === 'private') {
-            this.checkRequiredCredentials();
-            let auth = postData + '/api/';
-            if (api !== 'private') {
-                auth += api + '/';
-            }
-            auth += endpoint; // 1
-            const hash = this.hash(this.encode(auth), sha256.sha256, 'binary'); // 2
-            const secret = this.base64ToBinary(this.secret); // 3
-            const signature = this.hmac(hash, secret, sha512.sha512, 'base64'); // 4-5
-            headers = {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Accept': 'application/json',
-                'APIKey': this.apiKey,
-                'Authent': signature,
-            };
-        }
-        return { 'url': url, 'method': method, 'body': body, 'headers': headers };
-    }
-}
-
-module.exports = krakenfutures;