ccxt 4.3.44 → 4.3.45

package/js/src/static_dependencies/jsencrypt/lib/jsbn/jsbn.d.ts

@@ -15,7 +15,7 @@ export declare class BigInteger {
     protected intValue(): number;
     protected byteValue(): number;
     protected shortValue(): number;
-    protected signum(): 0 | 1 | -1;
+    protected signum(): 1 | 0 | -1;
     toByteArray(): number[];
     protected equals(a: BigInteger): boolean;
     protected min(a: BigInteger): BigInteger;

package/js/src/wavesexchange.d.ts

@@ -43,13 +43,12 @@ export default class wavesexchange extends Exchange {
     getMatcherPublicKey(): Promise<any>;
     getAssetBytes(currencyId: any): Uint8Array;
     getAssetId(currencyId: any): any;
-    customPriceToPrecision(symbol: any, price: any): number;
-    customAmountToPrecision(symbol: any, amount: any): number;
-    customCurrencyToPrecision(code: any, amount: any, networkCode?: any): number;
-    fromPrecision(amount: any, scale: any): string;
-    toPrecision(amount: any, scale: any): string;
-    currencyFromPrecision(currency: any, amount: any): string;
-    priceFromPrecision(symbol: any, price: any): string;
+    toRealCurrencyAmount(code: string, amount: number, networkCode?: any): number;
+    fromRealCurrencyAmount(code: string, amountString: string): string;
+    toRealSymbolPrice(symbol: string, price: number): number;
+    fromRealSymbolPrice(symbol: string, priceString: string): string;
+    toRealSymbolAmount(symbol: string, amount: number): number;
+    fromRealSymbolAmount(symbol: string, amountString: string): string;
     safeGetDynamic(settings: any): any;
     safeGetRates(dynamic: any): any;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
@@ -63,6 +62,7 @@ export default class wavesexchange extends Exchange {
     parseOrder(order: Dict, market?: Market): Order;
     getWavesAddress(): Promise<any>;
     fetchBalance(params?: {}): Promise<Balances>;
+    setUndefinedBalancesToZero(balances: any, key?: string): any;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseTrade(trade: Dict, market?: Market): Trade;

package/js/src/wavesexchange.js

@@ -9,7 +9,7 @@ import Exchange from './abstract/wavesexchange.js';
 import { AuthenticationError, InsufficientFunds, InvalidOrder, AccountSuspended, ExchangeError, DuplicateOrderId, OrderNotFound, BadSymbol, ExchangeNotAvailable, BadRequest, ArgumentsRequired } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { ed25519 } from './static_dependencies/noble-curves/ed25519.js';
-import { DECIMAL_PLACES } from './base/functions/number.js';
+import { TICK_SIZE } from './base/functions/number.js';
 //  ---------------------------------------------------------------------------
 /**
  * @class wavesexchange
@@ -318,9 +318,9 @@ export default class wavesexchange extends Exchange {
                 },
             },
             'currencies': {
-                'WX': this.safeCurrencyStructure({ 'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': undefined, 'code': 'WX', 'precision': this.parseToInt('8') }),
+                'WX': this.safeCurrencyStructure({ 'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': undefined, 'code': 'WX', 'precision': this.parseNumber('1e-8') }),
             },
-            'precisionMode': DECIMAL_PLACES,
+            'precisionMode': TICK_SIZE,
             'options': {
                 'allowedCandles': 1440,
                 'accessToken': undefined,
@@ -331,7 +331,7 @@ export default class wavesexchange extends Exchange {
                 'wavesAddress': undefined,
                 'withdrawFeeUSDN': 7420,
                 'withdrawFeeWAVES': 100000,
-                'wavesPrecision': 8,
+                'wavesPrecision': 1e-8,
                 'messagePrefix': 'W',
                 'networks': {
                     'ERC20': 'ETH',
@@ -379,8 +379,8 @@ export default class wavesexchange extends Exchange {
     async getFeesForAsset(symbol, side, amount, price, params = {}) {
         await this.loadMarkets();
         const market = this.market(symbol);
-        amount = this.customAmountToPrecision(symbol, amount);
-        price = this.customPriceToPrecision(symbol, price);
+        amount = this.toRealSymbolAmount(symbol, amount);
+        price = this.toRealSymbolPrice(symbol, price);
         const request = this.extend({
             'baseId': market['baseId'],
             'quoteId': market['quoteId'],
@@ -413,7 +413,7 @@ export default class wavesexchange extends Exchange {
         const matcherFee = this.safeString(mode, 'matcherFee');
         const feeAssetId = this.safeString(mode, 'feeAssetId');
         const feeAsset = this.safeCurrencyCode(feeAssetId);
-        const adjustedMatcherFee = this.currencyFromPrecision(feeAsset, matcherFee);
+        const adjustedMatcherFee = this.fromRealCurrencyAmount(feeAsset, matcherFee);
         const amountAsString = this.numberToString(amount);
         const priceAsString = this.numberToString(price);
         const feeCost = this.feeToPrecision(symbol, this.parseNumber(adjustedMatcherFee));
@@ -566,8 +566,8 @@ export default class wavesexchange extends Exchange {
                 'strike': undefined,
                 'optionType': undefined,
                 'precision': {
-                    'amount': this.safeInteger(entry, 'amountAssetDecimals'),
-                    'price': this.safeInteger(entry, 'priceAssetDecimals'),
+                    'amount': this.parseNumber(this.parsePrecision(this.safeString(entry, 'amountAssetDecimals'))),
+                    'price': this.parseNumber(this.parsePrecision(this.safeString(entry, 'priceAssetDecimals'))),
                 },
                 'limits': {
                     'leverage': {
@@ -624,12 +624,11 @@ export default class wavesexchange extends Exchange {
     }
     parseOrderBookSide(bookSide, market = undefined, limit = undefined) {
         const precision = market['precision'];
-        const wavesPrecision = this.safeString(this.options, 'wavesPrecision', '8');
-        const amountPrecision = '1e' + this.numberToString(precision['amount']);
-        const amountPrecisionString = this.numberToString(precision['amount']);
-        const pricePrecisionString = this.numberToString(precision['price']);
-        const difference = Precise.stringSub(amountPrecisionString, pricePrecisionString);
-        const pricePrecision = '1e' + Precise.stringSub(wavesPrecision, difference);
+        const wavesPrecision = this.safeString(this.options, 'wavesPrecision', '1e-8');
+        const amountPrecisionString = this.safeString(precision, 'amount');
+        const pricePrecisionString = this.safeString(precision, 'price');
+        const difference = Precise.stringDiv(amountPrecisionString, pricePrecisionString);
+        const pricePrecision = Precise.stringDiv(wavesPrecision, difference);
         const result = [];
         for (let i = 0; i < bookSide.length; i++) {
             const entry = bookSide[i];
@@ -638,10 +637,10 @@ export default class wavesexchange extends Exchange {
             let price = undefined;
             let amount = undefined;
             if ((pricePrecision !== undefined) && (entryPrice !== undefined)) {
-                price = Precise.stringDiv(entryPrice, pricePrecision);
+                price = Precise.stringMul(entryPrice, pricePrecision);
             }
-            if ((amountPrecision !== undefined) && (entryAmount !== undefined)) {
-                amount = Precise.stringDiv(entryAmount, amountPrecision);
+            if ((amountPrecisionString !== undefined) && (entryAmount !== undefined)) {
+                amount = Precise.stringMul(entryAmount, amountPrecisionString);
             }
             if ((limit !== undefined) && (i > limit)) {
                 break;
@@ -1227,51 +1226,36 @@ export default class wavesexchange extends Exchange {
         }
         return currencyId;
     }
-    customPriceToPrecision(symbol, price) {
-        const market = this.markets[symbol];
-        const wavesPrecision = this.safeString(this.options, 'wavesPrecision', '8');
-        const amount = this.numberToString(market['precision']['amount']);
-        const precisionPrice = this.numberToString(market['precision']['price']);
-        const difference = Precise.stringSub(amount, precisionPrice);
-        const precision = Precise.stringSub(wavesPrecision, difference);
-        const pricePrecision = this.toPrecision(price, precision).toString();
-        return this.parseToInt(parseFloat(pricePrecision));
-    }
-    customAmountToPrecision(symbol, amount) {
-        const amountPrecision = this.numberToString(this.toPrecision(amount, this.numberToString(this.markets[symbol]['precision']['amount'])));
-        return this.parseToInt(parseFloat(amountPrecision));
+    toRealCurrencyAmount(code, amount, networkCode = undefined) {
+        const currency = this.currency(code);
+        const stringValue = Precise.stringDiv(this.numberToString(amount), this.safeString(currency, 'precision'));
+        return parseInt(stringValue);
     }
-    customCurrencyToPrecision(code, amount, networkCode = undefined) {
-        const amountPrecision = this.numberToString(this.toPrecision(amount, this.currencies[code]['precision']));
-        return this.parseToInt(parseFloat(amountPrecision));
+    fromRealCurrencyAmount(code, amountString) {
+        if (!(code in this.currencies)) {
+            return amountString;
+        }
+        const currency = this.currency(code);
+        const precisionAmount = this.safeString(currency, 'precision');
+        return Precise.stringMul(amountString, precisionAmount);
     }
-    fromPrecision(amount, scale) {
-        if (amount === undefined) {
-            return undefined;
-        }
-        const precise = new Precise(amount);
-        precise.decimals = this.sum(precise.decimals, scale);
-        precise.reduce();
-        return precise.toString();
+    toRealSymbolPrice(symbol, price) {
+        const market = this.market(symbol);
+        const stringValue = Precise.stringDiv(this.numberToString(price), this.safeString(market['precision'], 'price'));
+        return parseInt(stringValue);
     }
-    toPrecision(amount, scale) {
-        const amountString = this.numberToString(amount);
-        const precise = new Precise(amountString);
-        // precise.decimals should be integer
-        precise.decimals = this.parseToInt(Precise.stringSub(this.numberToString(precise.decimals), this.numberToString(scale)));
-        precise.reduce();
-        const stringValue = precise.toString();
-        return stringValue;
+    fromRealSymbolPrice(symbol, priceString) {
+        const market = this.markets[symbol];
+        return Precise.stringMul(priceString, this.safeString(market['precision'], 'price'));
     }
-    currencyFromPrecision(currency, amount) {
-        const scale = this.currencies[currency]['precision'];
-        return this.fromPrecision(amount, scale);
+    toRealSymbolAmount(symbol, amount) {
+        const market = this.market(symbol);
+        const stringValue = Precise.stringDiv(this.numberToString(amount), this.safeString(market['precision'], 'amount'));
+        return parseInt(stringValue);
     }
-    priceFromPrecision(symbol, price) {
+    fromRealSymbolAmount(symbol, amountString) {
         const market = this.markets[symbol];
-        const wavesPrecision = this.safeInteger(this.options, 'wavesPrecision', 8);
-        const scale = this.sum(wavesPrecision, market['precision']['price']) - market['precision']['amount'];
-        return this.fromPrecision(price, scale);
+        return Precise.stringMul(amountString, market['precision']['amount']);
     }
     safeGetDynamic(settings) {
         const orderFee = this.safeValue(settings, 'orderFee');
@@ -1353,7 +1337,7 @@ export default class wavesexchange extends Exchange {
             }
             const matcherFeeAsset = this.safeCurrencyCode(matcherFeeAssetId);
             const rawMatcherFee = (matcherFeeAssetId === baseFeeAssetId) ? baseMatcherFee : discountMatcherFee;
-            const floatMatcherFee = parseFloat(this.currencyFromPrecision(matcherFeeAsset, rawMatcherFee));
+            const floatMatcherFee = parseFloat(this.fromRealCurrencyAmount(matcherFeeAsset, rawMatcherFee));
             if ((matcherFeeAsset in balances) && (balances[matcherFeeAsset]['free'] >= floatMatcherFee)) {
                 matcherFee = parseInt(rawMatcherFee);
             }
@@ -1361,26 +1345,26 @@ export default class wavesexchange extends Exchange {
                 throw new InsufficientFunds(this.id + ' not enough funds of the selected asset fee');
             }
         }
+        const floatBaseMatcherFee = this.fromRealCurrencyAmount(baseFeeAsset, baseMatcherFee);
+        const floatDiscountMatcherFee = this.fromRealCurrencyAmount(discountFeeAsset, discountMatcherFee);
         if (matcherFeeAssetId === undefined) {
             // try to the pay the fee using the base first then discount asset
-            const floatBaseMatcherFee = parseFloat(this.currencyFromPrecision(baseFeeAsset, baseMatcherFee));
-            if ((baseFeeAsset in balances) && (balances[baseFeeAsset]['free'] >= floatBaseMatcherFee)) {
+            if ((baseFeeAsset in balances) && (balances[baseFeeAsset]['free'] >= parseFloat(floatBaseMatcherFee))) {
                 matcherFeeAssetId = baseFeeAssetId;
                 matcherFee = parseInt(baseMatcherFee);
             }
             else {
-                const floatDiscountMatcherFee = parseFloat(this.currencyFromPrecision(discountFeeAsset, discountMatcherFee));
-                if ((discountFeeAsset in balances) && (balances[discountFeeAsset]['free'] >= floatDiscountMatcherFee)) {
+                if ((discountFeeAsset in balances) && (balances[discountFeeAsset]['free'] >= parseFloat(floatDiscountMatcherFee))) {
                     matcherFeeAssetId = discountFeeAssetId;
                     matcherFee = parseInt(discountMatcherFee);
                 }
             }
         }
         if (matcherFeeAssetId === undefined) {
-            throw new InsufficientFunds(this.id + ' not enough funds on none of the eligible asset fees');
+            throw new InsufficientFunds(this.id + ' not enough funds on none of the eligible asset fees: ' + baseFeeAsset + ' ' + floatBaseMatcherFee + ' or ' + discountFeeAsset + ' ' + floatDiscountMatcherFee);
         }
-        amount = this.customAmountToPrecision(symbol, amount);
-        price = this.customPriceToPrecision(symbol, price);
+        amount = this.toRealSymbolAmount(symbol, amount);
+        price = this.toRealSymbolPrice(symbol, price);
         const assetPair = {
             'amountAsset': amountAsset,
             'priceAsset': priceAsset,
@@ -1418,7 +1402,7 @@ export default class wavesexchange extends Exchange {
                 'c': {
                     't': 'sp',
                     'v': {
-                        'p': this.customPriceToPrecision(symbol, stopPrice),
+                        'p': this.toRealSymbolPrice(symbol, stopPrice),
                     },
                 },
             };
@@ -1766,24 +1750,24 @@ export default class wavesexchange extends Exchange {
             symbol = market['symbol'];
         }
         const amountCurrency = this.safeCurrencyCode(this.safeString(assetPair, 'amountAsset', 'WAVES'));
-        const price = this.priceFromPrecision(symbol, priceString);
-        const amount = this.currencyFromPrecision(amountCurrency, amountString);
-        const filled = this.currencyFromPrecision(amountCurrency, filledString);
-        const average = this.priceFromPrecision(symbol, this.safeString(order, 'avgWeighedPrice'));
+        const price = this.fromRealSymbolPrice(symbol, priceString);
+        const amount = this.fromRealCurrencyAmount(amountCurrency, amountString);
+        const filled = this.fromRealCurrencyAmount(amountCurrency, filledString);
+        const average = this.fromRealSymbolPrice(symbol, this.safeString(order, 'avgWeighedPrice'));
         const status = this.parseOrderStatus(this.safeString(order, 'status'));
         let fee = undefined;
         if ('type' in order) {
-            const currency = this.safeCurrencyCode(this.safeString(order, 'feeAsset'));
+            const code = this.safeCurrencyCode(this.safeString(order, 'feeAsset'));
             fee = {
-                'currency': currency,
-                'fee': this.parseNumber(this.currencyFromPrecision(currency, this.safeString(order, 'filledFee'))),
+                'currency': code,
+                'fee': this.parseNumber(this.fromRealCurrencyAmount(code, this.safeString(order, 'filledFee'))),
             };
         }
         else {
-            const currency = this.safeCurrencyCode(this.safeString(order, 'matcherFeeAssetId', 'WAVES'));
+            const code = this.safeCurrencyCode(this.safeString(order, 'matcherFeeAssetId', 'WAVES'));
             fee = {
-                'currency': currency,
-                'fee': this.parseNumber(this.currencyFromPrecision(currency, this.safeString(order, 'matcherFee'))),
+                'currency': code,
+                'fee': this.parseNumber(this.fromRealCurrencyAmount(code, this.safeString(order, 'matcherFee'))),
             };
         }
         let triggerPrice = undefined;
@@ -1896,7 +1880,7 @@ export default class wavesexchange extends Exchange {
         //   ]
         // }
         const balances = this.safeValue(totalBalance, 'balances', []);
-        const result = {};
+        let result = {};
         let timestamp = undefined;
         const assetIds = [];
         const nonStandardBalances = [];
@@ -1907,17 +1891,15 @@ export default class wavesexchange extends Exchange {
             const issueTransaction = this.safeValue(entry, 'issueTransaction');
             const currencyId = this.safeString(entry, 'assetId');
             const balance = this.safeString(entry, 'balance');
-            if (issueTransaction === undefined) {
+            const currencyExists = (currencyId in this.currencies_by_id);
+            if (currencyExists) {
+                const code = this.safeCurrencyCode(currencyId);
+                result[code] = this.account();
+                result[code]['total'] = this.fromRealCurrencyAmount(code, balance);
+            }
+            else if (issueTransaction === undefined) {
                 assetIds.push(currencyId);
                 nonStandardBalances.push(balance);
-                continue;
-            }
-            const decimals = this.safeInteger(issueTransaction, 'decimals');
-            let code = undefined;
-            if (currencyId in this.currencies_by_id) {
-                code = this.safeCurrencyCode(currencyId);
-                result[code] = this.account();
-                result[code]['total'] = this.fromPrecision(balance, decimals);
             }
         }
         const nonStandardAssets = assetIds.length;
@@ -1931,11 +1913,11 @@ export default class wavesexchange extends Exchange {
                 const entry = data[i];
                 const balance = nonStandardBalances[i];
                 const inner = this.safeValue(entry, 'data');
-                const decimals = this.safeInteger(inner, 'precision');
+                const precision = this.parsePrecision(this.safeString(inner, 'precision'));
                 const ticker = this.safeString(inner, 'ticker');
                 const code = this.safeCurrencyCode(ticker);
                 result[code] = this.account();
-                result[code]['total'] = this.fromPrecision(balance, decimals);
+                result[code]['total'] = Precise.stringMul(balance, precision);
             }
         }
         const currentTimestamp = this.milliseconds();
@@ -1961,12 +1943,7 @@ export default class wavesexchange extends Exchange {
                 result[code] = this.account();
             }
             const amount = this.safeString(reservedBalance, currencyId);
-            if (code in this.currencies) {
-                result[code]['used'] = this.currencyFromPrecision(code, amount);
-            }
-            else {
-                result[code]['used'] = amount;
-            }
+            result[code]['used'] = this.fromRealCurrencyAmount(code, amount);
         }
         const wavesRequest = {
             'address': wavesAddress,
@@ -1977,18 +1954,22 @@ export default class wavesexchange extends Exchange {
         //   "confirmations": 0,
         //   "balance": 909085978
         // }
-        result['WAVES'] = this.safeValue(result, 'WAVES', {});
-        result['WAVES']['total'] = this.currencyFromPrecision('WAVES', this.safeString(wavesTotal, 'balance'));
-        const codes = Object.keys(result);
+        result['WAVES'] = this.safeValue(result, 'WAVES', this.account());
+        result['WAVES']['total'] = this.fromRealCurrencyAmount('WAVES', this.safeString(wavesTotal, 'balance'));
+        result = this.setUndefinedBalancesToZero(result);
+        result['timestamp'] = timestamp;
+        result['datetime'] = this.iso8601(timestamp);
+        return this.safeBalance(result);
+    }
+    setUndefinedBalancesToZero(balances, key = 'used') {
+        const codes = Object.keys(balances);
         for (let i = 0; i < codes.length; i++) {
             const code = codes[i];
-            if (this.safeValue(result[code], 'used') === undefined) {
-                result[code]['used'] = '0';
+            if (this.safeValue(balances[code], 'used') === undefined) {
+                balances[code][key] = '0';
             }
         }
-        result['timestamp'] = timestamp;
-        result['datetime'] = this.iso8601(timestamp);
-        return this.safeBalance(result);
+        return balances;
     }
     async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
@@ -2526,7 +2507,7 @@ export default class wavesexchange extends Exchange {
         const feeAssetId = 'WAVES';
         const type = 4; // transfer
         const version = 2;
-        const amountInteger = this.customCurrencyToPrecision(code, amount);
+        const amountInteger = this.toRealCurrencyAmount(code, amount);
         const currency = this.currency(code);
         const timestamp = this.milliseconds();
         const byteArray = [
@@ -2586,18 +2567,45 @@ export default class wavesexchange extends Exchange {
         //         "amount": 0
         //     }
         //
+        // withdraw new:
+        //     {
+        //         type: "4",
+        //         id: "2xnWTqG9ar7jEDrLxfbVyyspPZ6XZNrrw9ai9sQ81Eya",
+        //         fee: "100000",
+        //         feeAssetId: null,
+        //         timestamp: "1715786263807",
+        //         version: "2",
+        //         sender: "3P81LLX1kk2CSJC9L8C2enxdHB7XvnSGAEE",
+        //         senderPublicKey: "DdmzmXf9mty1FBE8AdVGnrncVLEAzP4gR4nWoTFAJoXz",
+        //         proofs: [ "RyoKwdSYv3EqotJCYftfFM9JE2j1ZpDRxKwYfiRhLAFeyNp6VfJUXNDS884XfeCeHeNypNmTCZt5NYR1ekyjCX3", ],
+        //         recipient: "3P9tXxu38a8tgewNEKFzourVxeqHd11ppOc",
+        //         assetId: null,
+        //         feeAsset: null,
+        //         amount: "2000000",
+        //         attachment: "",
+        //     }
+        //
         currency = this.safeCurrency(undefined, currency);
+        const code = currency['code'];
+        const typeRaw = this.safeString(transaction, 'type');
+        const type = (typeRaw === '4') ? 'withdraw' : 'deposit';
+        const amount = this.parseNumber(this.fromRealCurrencyAmount(code, this.safeString(transaction, 'amount')));
+        const feeString = this.safeString(transaction, 'fee');
+        const feeAssetId = this.safeString(transaction, 'feeAssetId', 'WAVES');
+        const feeCode = this.safeCurrencyCode(feeAssetId);
+        const feeAmount = this.parseNumber(this.fromRealCurrencyAmount(feeCode, feeString));
+        const timestamp = this.safeInteger(transaction, 'timestamp');
         return {
-            'id': undefined,
+            'id': this.safeString(transaction, 'id'),
             'txid': undefined,
-            'timestamp': undefined,
-            'datetime': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
             'network': undefined,
-            'addressFrom': undefined,
+            'addressFrom': this.safeString(transaction, 'sender'),
             'address': undefined,
-            'addressTo': undefined,
-            'amount': undefined,
-            'type': undefined,
+            'addressTo': this.safeString(transaction, 'recipient'),
+            'amount': amount,
+            'type': type,
             'currency': currency['code'],
             'status': undefined,
             'updated': undefined,
@@ -2606,7 +2614,10 @@ export default class wavesexchange extends Exchange {
             'tagTo': undefined,
             'comment': undefined,
             'internal': undefined,
-            'fee': undefined,
+            'fee': {
+                'currency': feeCode,
+                'cost': feeAmount,
+            },
             'info': transaction,
         };
     }

package/js/src/xt.js

@@ -23,7 +23,7 @@ export default class xt extends Exchange {
             // futures 1000 times per minute for each single IP -> Otherwise account locked for 10min
             'rateLimit': 100,
             'version': 'v4',
-            'certified': true,
+            'certified': false,
             'pro': false,
             'has': {
                 'CORS': false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.3.44",
+  "version": "4.3.45",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",