Bybit Updated

'use strict';

const ccxt = require ('../../dist/cjs/ccxt.js');

console.log ('CCXT Version:', ccxt.version)

const exchange = new ccxt.bybit ({
   'apiKey': 'YOUR_API_KEY',
   'secret': 'YOUR_SECRET_KEY',
})

// Example 1: Spot : fetch balance, create order, cancel it and check canceled orders
async function example1 () {
   exchange['options']['defaultType'] = 'spot'; // very important set spot as default type

   await exchange.loadMarkets ();

   // fetch spot balance
   const balance = await exchange.fetchBalance ();
   console.log (balance)

   // create order
   const symbol = 'LTC/USDT';
   const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', 50, 0.1);
   console.log ('Created order id:', createOrder['id'])

   // cancel order
   const cancelOrder = await exchange.cancelOrder (createOrder['id'], symbol);

   // Check canceled orders (bybit does not have a single endpoint to check orders
   // we have to choose whether to check open or closed orders and call fetchOpenOrders
   // or fetchClosedOrders respectively
   const canceledOrders = await exchange.fetchClosedOrders (symbol);
   console.log (canceledOrders);
}

// -----------------------------------------------------------------------------------------

// Example 2 :: Swap : fetch balance, open a position and close it
async function example2 () {
   exchange['options']['defaultType'] = 'swap'; // very important set swap as default type
   await exchange.loadMarkets ();

   // fetch swap balance
   const balance = await exchange.fetchBalance ();
   console.log (balance)

   // create order and open position
   const symbol = 'LTC/USDT:USDT';
   const createOrder = await exchange.createOrder (symbol, 'market', 'buy', 0.1);
   console.log ('Created order id:', createOrder['id'])

   // check opened position
   const symbols = [ symbol ];
   const positions = await exchange.fetchPositions (symbols);
   console.log (positions)

   // Close position by issuing a order in the opposite direction
   const params = {
       'reduce_only': true
   }
   const closePositionOrder = await exchange.createOrder (symbol, 'market', 'sell', 0.1, undefined, params);
   console.log (closePositionOrder);
}

// -----------------------------------------------------------------------------------------

// Example 3 :: USDC Swap : fetch balance, open a position and close it
async function example3 () {
   exchange['options']['defaultType'] = 'swap'; // very important set swap as default type
   await exchange.loadMarkets ();

   // fetch USDC swap balance
   // when no symbol is available we can show our intent
   // of using USDC endpoints by either using defaultSettle in options or
   // settle in params
   // Using Options: exchange['options']['defaultSettle'] = 'USDC';
   // Using params:
   const balanceParams = {
       'settle': 'USDC'
   }
   const balance = await exchange.fetchBalance (balanceParams);
   console.log (balance)

   // create order and open position
   // taking into consideration that USDC markets do not support
   // market orders
   const symbol = 'BTC/USD:USDC';
   const amount = 0.1;
   const price = 29940 // adjust this accordingly
   const createOrder = await exchange.createOrder (symbol, 'limit', 'buy', amount, price);
   console.log ('Created order id:', createOrder['id'])

   // check if the order was filled and the position opened
   const symbols = [ symbol ];
   const positions = await exchange.fetchPositions (symbols);
   console.log (positions)

   // close position (assuming it was already opened) by issuing an order in the opposite direction
   const params = {
       'reduce_only': true
   }
   const closePositionOrder = await exchange.createOrder (symbol, 'limit', 'sell', amount, price, params);
   console.log (closePositionOrder);
}

// -----------------------------------------------------------------------------------------

// Example 4 :: Future : fetch balance, create stop-order and check open stop-orders
async function example4 () {
   exchange['options']['defaultType'] = 'future'; // very important set future as default type
   await exchange.loadMarkets ();

   // fetch future balance
   const balance = await exchange.fetchBalance ();
   console.log (balance)

   // create stop-order
   const symbol = 'ETH/USD:ETH-220930';
   const amount = 10; // in USD for inverse futures
   const price = 1200;
   const side = 'buy';
   const type = 'limit';
   const stopOrderParams = {
       'position_idx': 0, // 0 One-Way Mode, 1 Buy-side, 2 Sell-side, default = 0
       'stopPrice': 1000, // mandatory for stop orders
       'basePrice': 1100  // mandatory for stop orders
   }
   const stopOrder = await exchange.createOrder (symbol, type, side, amount, price, stopOrderParams);
   console.log ('Created order id:', stopOrder['id'])

   // check opened stop-order
   const openOrderParams = {
       'stop': true
   }
   const openOrders = await exchange.fetchOpenOrders (symbol, undefined, undefined, openOrderParams);
   console.log (openOrders)

   // Cancell open stop-order
   const cancelOrder = await exchange.cancelOrder (stopOrder['id'], symbol, openOrderParams);
   console.log (cancelOrder);
}

// -----------------------------------------------------------------------------------------

async function main () {
   await example1 ();
   await example2 ();
   await example3 ();
   await example4 ();

}

main ();