ccxt 4.2.67 → 4.2.69

package/js/src/gemini.js

@@ -30,7 +30,7 @@ export default class gemini extends Exchange {
                 'CORS': undefined,
                 'spot': true,
                 'margin': false,
-                'swap': false,
+                'swap': true,
                 'future': false,
                 'option': false,
                 'addMargin': false,
@@ -255,11 +255,11 @@ export default class gemini extends Exchange {
                 },
             },
             'options': {
-                'fetchMarketsMethod': 'fetch_markets_from_web',
+                'fetchMarketsMethod': 'fetch_markets_from_api',
                 'fetchMarketFromWebRetries': 10,
                 'fetchMarketsFromAPI': {
                     'fetchDetailsForAllSymbols': false,
-                    'fetchDetailsForMarketIds': [],
+                    'quoteCurrencies': ['USDT', 'GUSD', 'USD', 'DAI', 'EUR', 'GBP', 'SGD', 'BTC', 'ETH', 'LTC', 'BCH'],
                 },
                 'fetchMarkets': {
                     'webApiEnable': true,
@@ -315,10 +315,7 @@ export default class gemini extends Exchange {
         }
         //
         //    {
-        //        "tradingPairs": [
-        //            [ "BTCAUD", 2, 8, "0.00001", 10, true ],
-        //            ...
-        //        ],
+        //        "tradingPairs": [ [ 'BTCUSD', 2, 8, '0.00001', 10, true ],  ... ],
         //        "currencies": [
         //            [ "ORCA", "Orca", 204, 6, 0, 6, 8, false, null, "solana" ], // as confirmed, precisions seem to be the 5th index
         //            [ "ATOM", "Cosmos", 44, 6, 0, 6, 8, false, null, "cosmos" ],
@@ -337,6 +334,7 @@ export default class gemini extends Exchange {
         //    }
         //
         const result = {};
+        this.options['tradingPairs'] = this.safeList(data, 'tradingPairs');
         const currenciesArray = this.safeValue(data, 'currencies', []);
         for (let i = 0; i < currenciesArray.length; i++) {
             const currency = currenciesArray[i];
@@ -546,7 +544,7 @@ export default class gemini extends Exchange {
         return result;
     }
     async fetchMarketsFromAPI(params = {}) {
-        const response = await this.publicGetV1Symbols(params);
+        const marketIdsRaw = await this.publicGetV1Symbols(params);
         //
         //     [
         //         "btcusd",
@@ -554,93 +552,185 @@ export default class gemini extends Exchange {
         //         ...
         //     ]
         //
-        const result = {};
-        for (let i = 0; i < response.length; i++) {
-            const marketId = response[i];
-            const market = {
-                'symbol': marketId,
-            };
-            result[marketId] = this.parseMarket(market);
+        const result = [];
+        const options = this.safeDict(this.options, 'fetchMarketsFromAPI', {});
+        const bugSymbol = 'efilfil'; // we skip this inexistent test symbol, which bugs other functions
+        const marketIds = [];
+        for (let i = 0; i < marketIdsRaw.length; i++) {
+            if (marketIdsRaw[i] !== bugSymbol) {
+                marketIds.push(marketIdsRaw[i]);
+            }
         }
-        const options = this.safeValue(this.options, 'fetchMarketsFromAPI', {});
-        const fetchDetailsForAllSymbols = this.safeBool(options, 'fetchDetailsForAllSymbols', false);
-        const fetchDetailsForMarketIds = this.safeValue(options, 'fetchDetailsForMarketIds', []);
-        let promises = [];
-        let marketIds = [];
-        if (fetchDetailsForAllSymbols) {
-            marketIds = response;
+        if (this.safeBool(options, 'fetchDetailsForAllSymbols', false)) {
+            const promises = [];
+            for (let i = 0; i < marketIds.length; i++) {
+                const marketId = marketIds[i];
+                const request = {
+                    'symbol': marketId,
+                };
+                promises.push(this.publicGetV1SymbolsDetailsSymbol(this.extend(request, params)));
+                //
+                //     {
+                //         "symbol": "BTCUSD",
+                //         "base_currency": "BTC",
+                //         "quote_currency": "USD",
+                //         "tick_size": 1E-8,
+                //         "quote_increment": 0.01,
+                //         "min_order_size": "0.00001",
+                //         "status": "open",
+                //         "wrap_enabled": false
+                //     }
+                //
+            }
+            const responses = await Promise.all(promises);
+            for (let i = 0; i < responses.length; i++) {
+                result.push(this.parseMarket(responses[i]));
+            }
         }
         else {
-            marketIds = fetchDetailsForMarketIds;
-        }
-        for (let i = 0; i < marketIds.length; i++) {
-            const marketId = marketIds[i];
-            const request = {
-                'symbol': marketId,
-            };
-            promises.push(this.publicGetV1SymbolsDetailsSymbol(this.extend(request, params)));
-            //
-            //     {
-            //         "symbol": "BTCUSD",
-            //         "base_currency": "BTC",
-            //         "quote_currency": "USD",
-            //         "tick_size": 1E-8,
-            //         "quote_increment": 0.01,
-            //         "min_order_size": "0.00001",
-            //         "status": "open",
-            //         "wrap_enabled": false
-            //     }
-            //
-        }
-        promises = await Promise.all(promises);
-        for (let i = 0; i < promises.length; i++) {
-            const responseInner = promises[i];
-            const marketId = this.safeStringLower(responseInner, 'symbol');
-            result[marketId] = this.parseMarket(responseInner);
+            // use trading-pairs info, if it was fetched
+            const tradingPairs = this.safeList(this.options, 'tradingPairs');
+            if (tradingPairs !== undefined) {
+                const indexedTradingPairs = this.indexBy(tradingPairs, 0);
+                for (let i = 0; i < marketIds.length; i++) {
+                    const marketId = marketIds[i];
+                    const tradingPair = this.safeList(indexedTradingPairs, marketId.toUpperCase());
+                    if (tradingPair !== undefined) {
+                        result.push(this.parseMarket(tradingPair));
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < marketIds.length; i++) {
+                    result.push(this.parseMarket(marketIds[i]));
+                }
+            }
         }
-        return this.toArray(result);
+        return result;
     }
     parseMarket(response) {
-        const marketId = this.safeStringLower(response, 'symbol');
-        let baseId = this.safeString(response, 'base_currency');
-        let quoteId = this.safeString(response, 'quote_currency');
-        if (baseId === undefined) {
-            const idLength = marketId.length - 0;
-            const isUSDT = marketId.indexOf('usdt') >= 0;
-            const quoteSize = isUSDT ? 4 : 3;
-            baseId = marketId.slice(0, idLength - quoteSize); // Not true for all markets
-            quoteId = marketId.slice(idLength - quoteSize, idLength);
+        //
+        // response might be:
+        //
+        //     btcusd
+        //
+        // or
+        //
+        //     [
+        //         'BTCUSD',   // symbol
+        //         2,          // priceTickDecimalPlaces
+        //         8,          // quantityTickDecimalPlaces
+        //         '0.00001',  // quantityMinimum
+        //         10,         // quantityRoundDecimalPlaces
+        //         true        // minimumsAreInclusive
+        //     ],
+        //
+        // or
+        //
+        //     {
+        //         "symbol": "BTCUSD", // perpetuals have 'PERP' suffix, i.e. DOGEUSDPERP
+        //         "base_currency": "BTC",
+        //         "quote_currency": "USD",
+        //         "tick_size": 1E-8,
+        //         "quote_increment": 0.01,
+        //         "min_order_size": "0.00001",
+        //         "status": "open",
+        //         "wrap_enabled": false
+        //         "product_type": "swap", // only in perps
+        //         "contract_type": "linear", // only in perps
+        //         "contract_price_currency": "GUSD" // only in perps
+        //     }
+        //
+        let marketId = undefined;
+        let baseId = undefined;
+        let quoteId = undefined;
+        let settleId = undefined;
+        let tickSize = undefined;
+        let increment = undefined;
+        let minSize = undefined;
+        let status = undefined;
+        let swap = false;
+        let contractSize = undefined;
+        let linear = undefined;
+        let inverse = undefined;
+        const isString = (typeof response === 'string');
+        const isArray = (Array.isArray(response));
+        if (!isString && !isArray) {
+            marketId = this.safeStringLower(response, 'symbol');
+            minSize = this.safeNumber(response, 'min_order_size');
+            tickSize = this.safeNumber(response, 'tick_size');
+            increment = this.safeNumber(response, 'quote_increment');
+            status = this.parseMarketActive(this.safeString(response, 'status'));
+            baseId = this.safeString(response, 'base_currency');
+            quoteId = this.safeString(response, 'quote_currency');
+            settleId = this.safeString(response, 'contract_price_currency');
+        }
+        else {
+            // if no detailed API was called, then parse either string or array
+            if (isString) {
+                marketId = response;
+            }
+            else {
+                marketId = this.safeStringLower(response, 0);
+                minSize = this.safeNumber(response, 3);
+                tickSize = this.parseNumber(this.parsePrecision(this.safeString(response, 1)));
+                increment = this.parseNumber(this.parsePrecision(this.safeString(response, 2)));
+            }
+            const marketIdUpper = marketId.toUpperCase();
+            const isPerp = (marketIdUpper.indexOf('PERP') >= 0);
+            const marketIdWithoutPerp = marketIdUpper.replace('PERP', '');
+            const quoteQurrencies = this.handleOption('fetchMarketsFromAPI', 'quoteCurrencies', []);
+            for (let i = 0; i < quoteQurrencies.length; i++) {
+                const quoteCurrency = quoteQurrencies[i];
+                if (marketIdWithoutPerp.endsWith(quoteCurrency)) {
+                    baseId = marketIdWithoutPerp.replace(quoteCurrency, '');
+                    quoteId = quoteCurrency;
+                    if (isPerp) {
+                        settleId = quoteCurrency; // always same
+                    }
+                    break;
+                }
+            }
         }
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
-        const status = this.safeString(response, 'status');
+        const settle = this.safeCurrencyCode(settleId);
+        let symbol = base + '/' + quote;
+        if (settleId !== undefined) {
+            symbol = symbol + ':' + settle;
+            swap = true;
+            contractSize = tickSize; // always same
+            linear = true; // always linear
+            inverse = false;
+        }
+        const type = swap ? 'swap' : 'spot';
         return {
             'id': marketId,
-            'symbol': base + '/' + quote,
+            'symbol': symbol,
             'base': base,
             'quote': quote,
-            'settle': undefined,
+            'settle': settle,
             'baseId': baseId,
             'quoteId': quoteId,
-            'settleId': undefined,
-            'type': 'spot',
-            'spot': true,
+            'settleId': settleId,
+            'type': type,
+            'spot': !swap,
             'margin': false,
-            'swap': false,
+            'swap': swap,
             'future': false,
             'option': false,
-            'active': this.parseMarketActive(status),
-            'contract': false,
-            'linear': undefined,
-            'inverse': undefined,
-            'contractSize': undefined,
+            'active': status,
+            'contract': swap,
+            'linear': linear,
+            'inverse': inverse,
+            'contractSize': contractSize,
             'expiry': undefined,
             'expiryDatetime': undefined,
             'strike': undefined,
             'optionType': undefined,
             'precision': {
-                'price': this.safeNumber(response, 'quote_increment'),
-                'amount': this.safeNumber(response, 'tick_size'),
+                'price': increment,
+                'amount': tickSize,
             },
             'limits': {
                 'leverage': {
@@ -648,7 +738,7 @@ export default class gemini extends Exchange {
                     'max': undefined,
                 },
                 'amount': {
-                    'min': this.safeNumber(response, 'min_order_size'),
+                    'min': minSize,
                     'max': undefined,
                 },
                 'price': {

package/js/src/hitbtc.js

@@ -318,6 +318,7 @@ export default class hitbtc extends Exchange {
                     '2012': BadRequest,
                     '2020': BadRequest,
                     '2022': BadRequest,
+                    '2024': InvalidOrder,
                     '10001': BadRequest,
                     '10021': AccountSuspended,
                     '10022': BadRequest,
@@ -335,6 +336,7 @@ export default class hitbtc extends Exchange {
                     '20012': ExchangeError,
                     '20014': ExchangeError,
                     '20016': ExchangeError,
+                    '20018': ExchangeError,
                     '20031': ExchangeError,
                     '20032': ExchangeError,
                     '20033': ExchangeError,
@@ -345,10 +347,15 @@ export default class hitbtc extends Exchange {
                     '20043': ExchangeError,
                     '20044': PermissionDenied,
                     '20045': InvalidOrder,
+                    '20047': InvalidOrder,
+                    '20048': InvalidOrder,
+                    '20049': InvalidOrder,
                     '20080': ExchangeError,
                     '21001': ExchangeError,
                     '21003': AccountSuspended,
                     '21004': AccountSuspended,
+                    '22004': ExchangeError,
+                    '22008': ExchangeError, // Gateway timeout exceeded.
                 },
                 'broad': {},
             },

package/js/src/htx.js

@@ -470,6 +470,7 @@ export default class htx extends Exchange {
                             'v2/sub-user/api-key-modification': 1,
                             'v2/sub-user/api-key-deletion': 1,
                             'v1/subuser/transfer': 10,
+                            'v1/trust/user/active/credit': 10,
                             // Trading
                             'v1/order/orders/place': 0.2,
                             'v1/order/batch-orders': 0.4,

package/js/src/hyperliquid.js

@@ -885,13 +885,16 @@ export default class hyperliquid extends Exchange {
             }
             orderReq.push(orderObj);
         }
+        const vaultAddress = this.safeString(params, 'vaultAddress');
         const orderAction = {
             'type': 'order',
             'orders': orderReq,
             'grouping': 'na',
-            'brokerCode': 1,
+            // 'brokerCode': 1, // cant
         };
-        const vaultAddress = this.safeString(params, 'vaultAddress');
+        if (vaultAddress === undefined) {
+            orderAction['brokerCode'] = 1;
+        }
         const signature = this.signL1Action(orderAction, nonce, vaultAddress);
         const request = {
             'action': orderAction,

package/js/src/krakenfutures.js

@@ -251,6 +251,9 @@ export default class krakenfutures extends Exchange {
                         },
                     },
                 },
+                'fetchTrades': {
+                    'method': 'historyGetMarketSymbolExecutions', // historyGetMarketSymbolExecutions, publicGetHistory
+                },
             },
             'timeframes': {
                 '1m': '1m',
@@ -700,6 +703,7 @@ export default class krakenfutures extends Exchange {
          * @method
          * @name krakenfutures#fetchTrades
          * @see https://docs.futures.kraken.com/#http-api-trading-v3-api-market-data-get-trade-history
+         * @see https://docs.futures.kraken.com/#http-api-history-market-history-get-public-execution-events
          * @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
@@ -707,6 +711,7 @@ export default class krakenfutures extends Exchange {
          * @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)
+         * @param {string} [params.method] The method to use to fetch trades. Can be 'historyGetMarketSymbolExecutions' or 'publicGetHistory' default is 'historyGetMarketSymbolExecutions'
          * @returns An array of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
          */
         await this.loadMarkets();
@@ -716,38 +721,113 @@ export default class krakenfutures extends Exchange {
             return await this.fetchPaginatedCallDynamic('fetchTrades', symbol, since, limit, params);
         }
         const market = this.market(symbol);
-        const request = {
+        let request = {
             'symbol': market['id'],
         };
-        const until = this.safeInteger(params, 'until');
-        if (until !== undefined) {
-            request['lastTime'] = this.iso8601(until);
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'fetchTrades', 'method', 'historyGetMarketSymbolExecutions');
+        let rawTrades = undefined;
+        const isFullHistoryEndpoint = (method === 'historyGetMarketSymbolExecutions');
+        if (isFullHistoryEndpoint) {
+            [request, params] = this.handleUntilOption('before', request, params);
+            if (since !== undefined) {
+                request['since'] = since;
+                request['sort'] = 'asc';
+            }
+            if (limit !== undefined) {
+                request['count'] = limit;
+            }
+            const response = await this.historyGetMarketSymbolExecutions(this.extend(request, params));
+            //
+            //    {
+            //        "elements": [
+            //            {
+            //                "uid": "a5105030-f054-44cc-98ab-30d5cae96bef",
+            //                "timestamp": "1710150778607",
+            //                "event": {
+            //                    "Execution": {
+            //                        "execution": {
+            //                            "uid": "2d485b71-cd28-4a1e-9364-371a127550d2",
+            //                            "makerOrder": {
+            //                                "uid": "0a25f66b-1109-49ec-93a3-d17bf9e9137e",
+            //                                "tradeable": "PF_XBTUSD",
+            //                                "direction": "Buy",
+            //                                "quantity": "0.26500",
+            //                                "timestamp": "1710150778570",
+            //                                "limitPrice": "71907",
+            //                                "orderType": "Post",
+            //                                "reduceOnly": false,
+            //                                "lastUpdateTimestamp": "1710150778570"
+            //                            },
+            //                            "takerOrder": {
+            //                                "uid": "04de3ee0-9125-4960-bf8f-f63b577b6790",
+            //                                "tradeable": "PF_XBTUSD",
+            //                                "direction": "Sell",
+            //                                "quantity": "0.0002",
+            //                                "timestamp": "1710150778607",
+            //                                "limitPrice": "71187.00",
+            //                                "orderType": "Market",
+            //                                "reduceOnly": false,
+            //                                "lastUpdateTimestamp": "1710150778607"
+            //                            },
+            //                            "timestamp": "1710150778607",
+            //                            "quantity": "0.0002",
+            //                            "price": "71907",
+            //                            "markPrice": "71903.32715463147",
+            //                            "limitFilled": false,
+            //                            "usdValue": "14.38"
+            //                        },
+            //                        "takerReducedQuantity": ""
+            //                    }
+            //                }
+            //            },
+            //            ... followed by older items
+            //        ],
+            //        "len": "1000",
+            //        "continuationToken": "QTexMDE0OTe33NTcyXy8xNDIzAjc1NjY5MwI="
+            //    }
+            //
+            const elements = this.safeList(response, 'elements', []);
+            // we need to reverse the list to fix chronology
+            rawTrades = [];
+            const length = elements.length;
+            for (let i = 0; i < length; i++) {
+                const index = length - 1 - i;
+                const element = elements[index];
+                const event = this.safeDict(element, 'event', {});
+                const executionContainer = this.safeDict(event, 'Execution', {});
+                const rawTrade = this.safeDict(executionContainer, 'execution', {});
+                rawTrades.push(rawTrade);
+            }
         }
-        //
-        //    {
-        //        "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);
+        else {
+            [request, params] = this.handleUntilOption('lastTime', request, params);
+            const response = await this.publicGetHistory(this.extend(request, params));
+            //
+            //    {
+            //        "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"
+            //    }
+            //
+            rawTrades = this.safeList(response, 'history', []);
+        }
+        return this.parseTrades(rawTrades, market, since, limit);
     }
     parseTrade(trade, market = undefined) {
         //
-        // fetchTrades (public)
+        // fetchTrades (recent trades)
         //
         //    {
         //        "time": "2019-02-14T09:25:33.920Z",
@@ -755,10 +835,24 @@ export default class krakenfutures extends Exchange {
         //        "price": 3574,
         //        "size": 100,
         //        "side": "buy",
-        //        "type": "fill"                                          // fill, liquidation, assignment, termination
+        //        "type": "fill" // fill, liquidation, assignment, termination
         //        "uid": "11c3d82c-9e70-4fe9-8115-f643f1b162d4"
         //    }
         //
+        // fetchTrades (executions history)
+        //
+        //    {
+        //        "timestamp": "1710152516830",
+        //        "price": "71927.0",
+        //        "quantity": "0.0695",
+        //        "markPrice": "71936.38701675525",
+        //        "limitFilled": true,
+        //        "usdValue": "4998.93",
+        //        "uid": "116ae634-253f-470b-bd20-fa9d429fb8b1",
+        //        "makerOrder": { "uid": "17bfe4de-c01e-4938-926c-617d2a2d0597", "tradeable": "PF_XBTUSD", "direction": "Buy", "quantity": "0.0695", "timestamp": "1710152515836", "limitPrice": "71927.0", "orderType": "Post", "reduceOnly": false, "lastUpdateTimestamp": "1710152515836" },
+        //        "takerOrder": { "uid": "d3e437b4-aa70-4108-b5cf-b1eecb9845b5", "tradeable": "PF_XBTUSD", "direction": "Sell", "quantity": "0.940100", "timestamp": "1710152516830", "limitPrice": "71915", "orderType": "IoC", "reduceOnly": false, "lastUpdateTimestamp": "1710152516830" }
+        //    }
+        //
         // fetchMyTrades (private)
         //
         //    {
@@ -797,9 +891,9 @@ export default class krakenfutures extends Exchange {
         //        "type": "EXECUTION"
         //    }
         //
-        const timestamp = this.parse8601(this.safeString2(trade, 'time', 'fillTime'));
+        let timestamp = this.parse8601(this.safeString2(trade, 'time', 'fillTime'));
         const price = this.safeString(trade, 'price');
-        const amount = this.safeString2(trade, 'size', 'amount', '0.0');
+        const amount = this.safeStringN(trade, ['size', 'amount', 'quantity'], '0.0');
         let id = this.safeString2(trade, 'uid', 'fill_id');
         if (id === undefined) {
             id = this.safeString(trade, 'executionId');
@@ -848,6 +942,15 @@ export default class krakenfutures extends Exchange {
                 takerOrMaker = 'maker';
             }
         }
+        const isHistoricalExecution = ('takerOrder' in trade);
+        if (isHistoricalExecution) {
+            timestamp = this.safeInteger(trade, 'timestamp');
+            const taker = this.safeDict(trade, 'takerOrder', {});
+            if (taker !== undefined) {
+                side = this.safeStringLower(taker, 'direction');
+                takerOrMaker = 'taker';
+            }
+        }
         return this.safeTrade({
             'info': trade,
             'id': id,

package/js/src/kucoin.js

@@ -413,6 +413,7 @@ export default class kucoin extends Exchange {
                 '12h': '12hour',
                 '1d': '1day',
                 '1w': '1week',
+                '1M': '1month',
             },
             'precisionMode': TICK_SIZE,
             'exceptions': {
@@ -4462,7 +4463,7 @@ export default class kucoin extends Exchange {
         url = url + endpoint;
         const isFuturePrivate = (api === 'futuresPrivate');
         const isPrivate = (api === 'private');
-        const isBroker = (api === 'private');
+        const isBroker = (api === 'broker');
         if (isPrivate || isFuturePrivate || isBroker) {
             this.checkRequiredCredentials();
             const timestamp = this.nonce().toString();
@@ -4494,7 +4495,9 @@ export default class kucoin extends Exchange {
             }
             if (isBroker) {
                 const brokerName = this.safeString(partner, 'name');
-                headers['KC-BROKER-NAME'] = brokerName;
+                if (brokerName !== undefined) {
+                    headers['KC-BROKER-NAME'] = brokerName;
+                }
             }
         }
         return { 'url': url, 'method': method, 'body': body, 'headers': headers };