ccxt 4.2.73 → 4.2.75

package/examples/ts/fetch-tickers/prettier.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  singleQuote: true,
+  trailingComma: 'es5',
+};

package/examples/ts/fetch-tickers/src/index.ts

@@ -0,0 +1,21 @@
+// Example code in typescript
+// Based on /examples/js/fetch-from-many-exchanges-simultaneously.js
+
+import * as ccxt from 'ccxt';
+const log = require('ololog');
+
+const symbol = 'BTC/USD';
+const exchanges = ['coinbasepro', 'gemini', 'kraken'];
+
+const fetchTickers = async (symbol: string) => {
+    const result = await Promise.all(exchanges.map(async (id: string): Promise<ccxt.Exchange> => {
+        const CCXT = ccxt as any; // Hack!
+        const exchange = new CCXT[id]({ 'enableRateLimit': true }) as ccxt.Exchange;
+        const ticker = await exchange.fetchTicker(symbol);
+        const exchangeExtended = exchange.extend({ 'exchange': id }, ticker) as ccxt.Exchange;
+        return exchangeExtended;
+    }));
+    log(result);
+};
+
+fetchTickers(symbol);

package/examples/ts/fetch-tickers/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "build",
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": [
+      "es2016"
+    ],
+    "module": "commonjs",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "pretty": true,
+    "sourceMap": true,
+    "strict": true,
+    "target": "es2017"
+  },
+  "include": [
+    "src/**/*.ts",
+    "test/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/examples/ts/how-to-import-one-exchange-esm.ts

@@ -0,0 +1,11 @@
+import { binance } from '../../js/ccxt.js';
+
+async function example () {
+    const exchange = new binance ({});
+    const ob = await exchange.fetchOrderBook ('BTC/USDT', 3);
+    const asks = ob['asks'];
+    const bids = ob['bids'];
+    console.log (asks);
+    console.log (bids);
+}
+example ();

package/examples/ts/kraken-create-and-close-position.ts

@@ -0,0 +1,69 @@
+// @ts-nocheck
+import ccxt from '../../js/ccxt.js';
+
+// AUTO-TRANSPILE //
+
+console.log ('CCXT Version:', ccxt.version);
+
+// ------------------------------------------------------------------------------
+
+async function example () {
+    const exchange = new ccxt.kraken ({
+        "apiKey": "YOUR_API_KEY",
+        "secret": "YOUR_API_SECRET",
+    });
+
+    const symbol = 'UNI/USD';
+    let side = 'buy'; // set it to 'buy' for a long position, 'sell' for a short position
+    const order_type = 'market'; // set it to 'market' or 'limit'
+    const amount = 1;
+    const leverage = 2;
+
+    await exchange.loadMarkets ();
+    const market = exchange.market (symbol);
+
+    // if order_type is 'market', then price is not needed
+    let price = undefined;
+    // if order_type is 'limit', then set a price at your desired level
+    // you can fetch the ticker and update price
+    // const ticker = await exchange.fetchTicker (symbol);
+    // const last_price = ticker['last'];
+    // const ask_price = ticker['ask'];
+    // const bid_price = ticker['bid'];
+    // if (order_type === 'limit') {
+    //     price = (side === 'buy') ? bid_price * 0.95 : ask_price * 1.05; // i.e. 5% from current price
+    // }
+
+    const params = {
+        'leverage': leverage,
+    };
+
+    // log
+    console.log ('Going to open a position', 'for', amount, 'worth', amount, market['base'], '~', market['settle'], 'using', side, order_type, 'order (', (order_type === 'limit' ? exchange.priceToPrecision (symbol, price) : ''), '), using the following params:');
+    console.log (params);
+    console.log ('-----------------------------------------------------------------------');
+
+    // exchange.verbose = True  // uncomment for debugging purposes if necessary
+
+    try {
+        const created_order = await exchange.createOrder (symbol, order_type, side, amount, price, params);
+        console.log ("Created an order", created_order);
+
+        // Fetch all your closed orders for this symbol (because we used market order)
+        // - use 'fetchClosedOrders' or 'fetchOrders' and filter with 'closed' status
+        const all_closed_orders = await exchange.fetchClosedOrders (symbol);
+        console.log ("Fetched all your closed orders for this symbol", all_closed_orders);
+
+        const all_open_positions = await exchange.fetchPositions (symbol);
+        console.log ("Fetched all your positions for this symbol", all_open_positions);
+
+        // To close a position:
+        // - long position (buy), you can create a sell order: exchange.createOrder (symbol, order_type, 'sell', amount, price, params);
+        // - short position (sell), you can create a buy order: exchange.createOrder (symbol, order_type, 'buy', amount, price, params);
+    } catch (e) {
+        console.log (e.toString ());
+    }
+}
+
+
+await example ();

package/examples/ts/margin-loan-borrow-buy-sell-repay.ts

@@ -0,0 +1,72 @@
+import ccxt from '../../js/ccxt.js';
+
+// AUTO-TRANSPILE //
+
+// Note, this is just an example and might not yet work on other exchanges, which are being still unified.
+
+async function example () {
+    // ########## user inputs ##########
+    const exchange = new ccxt['binance'] ({ 'apiKey': 'xxx', 'secret': 'xxx' });
+    const symbol = 'BUSD/USDT'; // set target symbol
+    const marginMode = 'isolated'; // margin mode (cross or isolated)
+    const collateral_coin = 'USDT';  // which asset you want to use for margin-borrow collateral
+    const borrow_coin = 'BUSD'; // which coin to borrow
+    const order_side: any = 'sell'; // which side to trade
+    const amount_to_trade = 14; // how many coins to sell
+    const order_type = 'limit'; // order type (can be market, limit or etc)
+    const limit_price: any = 0.99; // price to sell at (set undefined/null/None if market-order)
+    const margin_magnitude = 5; // target margin (aka 'leverage'). This might also be obtainable using other unified methods, but for example purposes, we set here manually
+    // ########## end of user-inputs ##########
+    //
+    // for example purposes, let's also check available balance at first
+    const balance_margin = await exchange.fetchBalance ({ 'defaultType': 'margin', 'marginMode': marginMode }); // use `defaultType` because of temporary bug, otherwise, after several days, you can use `type` too.
+    // if we don't have enought coins, then we have to borrow at first
+    let needed_amount_to_borrow: any = undefined;  // will be auto-set below
+    if (amount_to_trade > balance_margin[symbol][borrow_coin]['free']) {
+        needed_amount_to_borrow = amount_to_trade - balance_margin[symbol][borrow_coin]['free'];
+        console.log ('hmm, I have only ', balance_margin[symbol][borrow_coin]['free'], ' ', borrow_coin, ' in margin balance, and still need additional ', needed_amount_to_borrow, ' to make an order. Lets borrow it.');
+        // To initate a borrow, at first, check if we have enough collateral (for this example, as we make a sell-short, we need '-1' to keep for collateral currency)
+        const needed_collateral_amount = needed_amount_to_borrow / (margin_magnitude - 1);
+        // Check if we have any collateral to get permission for borrow
+        if (balance_margin[symbol][collateral_coin]['free'] < needed_collateral_amount) {
+            // If we don't have enough collateral, then let's try to transfer collateral-asset from spot-balance to margin-balance
+            console.log ('hmm, I have only ', balance_margin[symbol][collateral_coin]['free'], ' in balance, but ', needed_collateral_amount, ' collateral is needed. I should transfer ', needed_collateral_amount, ' from spot');
+            // let's check if we have spot balance at all
+            const balance_spot = await exchange.fetchBalance ({ 'type': 'spot' });
+            if (exchange.parseNumber (balance_spot[collateral_coin]['free']) < needed_collateral_amount) {
+                console.log ('hmm, I neither do have enough balance on spot - only ', balance_spot[collateral_coin]['free'], '. Script can not continue...');
+                return;
+            } else {
+                console.log ('Transferring  ', needed_collateral_amount, ' to margin account');
+                await exchange.transfer (collateral_coin, needed_collateral_amount, 'spot', marginMode, { 'symbol': symbol });
+            }
+        }
+        // now, as we have enough margin collateral, initiate borrow
+        console.log ('Initiating margin borrow of ', needed_amount_to_borrow, ' ', borrow_coin);
+        const borrowResult = await exchange.borrowMargin (borrow_coin, needed_amount_to_borrow, symbol, { 'marginMode': marginMode });
+    }
+    console.log ('Submitting order.');
+    const order = await exchange.createOrder (symbol, order_type, order_side, amount_to_trade, limit_price, { 'marginMode': marginMode });
+    console.log ('Order was submitted !', order['id']);
+    //
+    //
+    // ...
+    // ...
+    // some time later, if you want to repay the loan back (like 'close the position')...
+    // ...
+    // ...
+    //
+    //
+    // set the "repay-back" amount (for this example snippet, this will be same amount that we borrowed above)
+    if (needed_amount_to_borrow !== undefined) {
+        const amount_to_repay_back = needed_amount_to_borrow;
+        // At first, you need to get back the borrowed coin, by making an opposide trade
+        console.log ('Making purchase back of ', amount_to_repay_back, ' ', borrow_coin, ' to repay it back.');
+        const purchase_back_price: any = 1.01;
+        const order_back = await exchange.createOrder (symbol, order_type, (order_side === 'buy' ? 'sell' : 'buy'), amount_to_repay_back, purchase_back_price, { 'marginMode': marginMode });
+        console.log ('Now, repaying the loan.');
+        const repayResult = await exchange.repayMargin (borrow_coin, amount_to_repay_back, symbol, { 'marginMode': marginMode });
+        console.log ('finished.');
+    }
+}
+await example ();

package/examples/ts/nextjs-page-router/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "next/core-web-vitals"
+}

package/examples/ts/nextjs-page-router/README.md

@@ -0,0 +1,43 @@
+This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
+
+## Description
+
+This app demonstrates the use of ccxt with a nextjs project. It showcases the use of both ccxt as a server side package and also to be running in the client:
+
+- **/tickers**: uses the **clients Window websockets** to connect to the exchange and stream ticker values
+
+- **/balance**: uses a **server side call** to protect exposing any api keys and fetches and shows the user balance.
+
+## Getting Started
+
+1. install the dependencies:
+
+```bash
+npm run install
+```
+
+
+2. Set the keys in pages/balance.tsx
+
+3. Run the app:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+## Screenshots
+##### Index
+![menu](https://github.com/ccxt/ccxt/assets/12142844/645b5fe8-fd13-44f8-bded-20733843ccea)
+##### Client side websocket example
+![websocket](https://github.com/ccxt/ccxt/assets/12142844/7c28f8c9-aefd-4db3-8aff-6ff06b93a8bc)
+##### Server side private endpoint fetch balance
+![balance](https://github.com/ccxt/ccxt/assets/12142844/bd253903-43ea-4225-a7ca-193aaa29f42a)
+

package/examples/ts/nextjs-page-router/next.config.js

@@ -0,0 +1,6 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+}
+
+module.exports = nextConfig