ccxt 4.3.51 → 4.3.53

package/js/src/probit.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/probit.js';
-import { ExchangeError, ExchangeNotAvailable, BadResponse, BadRequest, InvalidOrder, InsufficientFunds, AuthenticationError, InvalidAddress, RateLimitExceeded, DDoSProtection, BadSymbol, ArgumentsRequired } from './base/errors.js';
+import { ExchangeError, ExchangeNotAvailable, BadResponse, BadRequest, InvalidOrder, InsufficientFunds, AuthenticationError, InvalidAddress, RateLimitExceeded, DDoSProtection, BadSymbol, MarketClosed, ArgumentsRequired } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { TRUNCATE, TICK_SIZE } from './base/functions/number.js';
 //  ---------------------------------------------------------------------------
@@ -182,7 +182,7 @@ export default class probit extends Exchange {
                     'RATE_LIMIT_EXCEEDED': RateLimitExceeded,
                     'MARKET_UNAVAILABLE': ExchangeNotAvailable,
                     'INVALID_MARKET': BadSymbol,
-                    'MARKET_CLOSED': BadSymbol,
+                    'MARKET_CLOSED': MarketClosed,
                     'MARKET_NOT_FOUND': BadSymbol,
                     'INVALID_CURRENCY': BadRequest,
                     'TOO_MANY_OPEN_ORDERS': DDoSProtection,
@@ -1839,11 +1839,16 @@ export default class probit extends Exchange {
         }
         if ('errorCode' in response) {
             const errorCode = this.safeString(response, 'errorCode');
-            const message = this.safeString(response, 'message');
             if (errorCode !== undefined) {
-                const feedback = this.id + ' ' + body;
-                this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
-                this.throwBroadlyMatchedException(this.exceptions['exact'], errorCode, feedback);
+                const errMessage = this.safeString(response, 'message', '');
+                const details = this.safeValue(response, 'details');
+                const feedback = this.id + ' ' + errorCode + ' ' + errMessage + ' ' + this.json(details);
+                if ('exact' in this.exceptions) {
+                    this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
+                }
+                if ('broad' in this.exceptions) {
+                    this.throwBroadlyMatchedException(this.exceptions['broad'], errMessage, feedback);
+                }
                 throw new ExchangeError(feedback);
             }
         }

package/js/src/static_dependencies/ethers/hash/typed-data.js

@@ -467,7 +467,7 @@ _TypedDataEncoder_types = new WeakMap(), _TypedDataEncoder_fullTypes = new WeakM
             if (__classPrivateFieldGet(this, _TypedDataEncoder_fullTypes, "f").has(subtype)) {
                 result = result.map(keccak256);
             }
-            return keccak256(concat(result));
+            return keccak256(getBytes(concat(result)));
         };
     }
     // Struct

package/js/src/vertex.d.ts

@@ -0,0 +1,112 @@
+import Exchange from './abstract/vertex.js';
+import type { Market, Ticker, Tickers, TradingFees, Balances, Int, OrderBook, OHLCV, Str, Order, OrderType, OrderSide, Trade, Strings, Dict, Num, Currencies } from './base/types.js';
+/**
+ * @class vertex
+ * @augments Exchange
+ */
+export default class vertex extends Exchange {
+    describe(): any;
+    setSandboxMode(enabled: any): void;
+    convertToX18(num: any): string;
+    convertFromX18(num: any): string;
+    fetchCurrencies(params?: {}): Promise<Currencies>;
+    parseMarket(market: any): Market;
+    fetchMarkets(params?: {}): Promise<Market[]>;
+    fetchTime(params?: {}): Promise<number>;
+    fetchStatus(params?: {}): Promise<{
+        status: string;
+        updated: any;
+        eta: any;
+        url: any;
+        info: any;
+    }>;
+    parseTrade(trade: any, market?: Market): Trade;
+    fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    fetchTradingFees(params?: {}): Promise<TradingFees>;
+    parseOHLCV(ohlcv: any, market?: Market): OHLCV;
+    fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    parseFundingRate(ticker: any, market?: Market): {
+        info: any;
+        symbol: string;
+        markPrice: number;
+        indexPrice: number;
+        interestRate: any;
+        estimatedSettlePrice: any;
+        timestamp: any;
+        datetime: any;
+        fundingRate: number;
+        fundingTimestamp: number;
+        fundingDatetime: string;
+        nextFundingRate: any;
+        nextFundingTimestamp: any;
+        nextFundingDatetime: any;
+        previousFundingRate: any;
+        previousFundingTimestamp: any;
+        previousFundingDatetime: any;
+    };
+    fetchFundingRate(symbol: string, params?: {}): Promise<{
+        info: any;
+        symbol: string;
+        markPrice: number;
+        indexPrice: number;
+        interestRate: any;
+        estimatedSettlePrice: any;
+        timestamp: any;
+        datetime: any;
+        fundingRate: number;
+        fundingTimestamp: number;
+        fundingDatetime: string;
+        nextFundingRate: any;
+        nextFundingTimestamp: any;
+        nextFundingDatetime: any;
+        previousFundingRate: any;
+        previousFundingTimestamp: any;
+        previousFundingDatetime: any;
+    }>;
+    fetchFundingRates(symbols?: Strings, params?: {}): Promise<any>;
+    parseOpenInterest(interest: any, market?: Market): import("./base/types.js").OpenInterest;
+    fetchOpenInterest(symbol: string, params?: {}): Promise<import("./base/types.js").OpenInterest>;
+    parseTicker(ticker: Dict, market?: Market): Ticker;
+    fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    queryContracts(params?: {}): Promise<Currencies>;
+    nonce(): number;
+    hashMessage(message: any): string;
+    signHash(hash: any, privateKey: any): string;
+    signMessage(message: any, privateKey: any): string;
+    buildSig(chainId: any, messageTypes: any, message: any, verifyingContractAddress?: string): string;
+    buildCreateOrderSig(message: any, chainId: any, verifyingContractAddress: any): string;
+    buildListTriggerTxSig(message: any, chainId: any, verifyingContractAddress: any): string;
+    buildCancelAllOrdersSig(message: any, chainId: any, verifyingContractAddress: any): string;
+    buildCancelOrdersSig(message: any, chainId: any, verifyingContractAddress: any): string;
+    buildWithdrawSig(message: any, chainId: any, verifyingContractAddress: any): string;
+    convertAddressToSender(address: string): string;
+    getNonce(now: any, expiration: any): string;
+    getExpiration(now: any, timeInForce: any, postOnly: any, reduceOnly: any): string;
+    getAmount(amount: any, side: any): string;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: Num, price?: Num, params?: {}): Promise<Order>;
+    parseOrderStatus(status: any): any;
+    parseOrder(order: any, market?: Market): Order;
+    parseTimeInForce(timeInForce: any): string;
+    fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
+    fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
+    cancelOrders(ids: string[], symbol?: Str, params?: {}): Promise<any>;
+    fetchBalance(params?: {}): Promise<Balances>;
+    parsePosition(position: any, market?: Market): import("./base/types.js").Position;
+    fetchPositions(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Position[]>;
+    queryNonces(): Promise<import("./base/types.js").Dictionary<any>>;
+    withdraw(code: string, amount: any, address: any, tag?: any, params?: {}): Promise<any>;
+    handlePublicAddress(methodName: string, params: Dict): any[];
+    handleErrors(code: any, reason: any, url: any, method: any, headers: any, body: any, response: any, requestHeaders: any, requestBody: any): any;
+    sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
+        url: string;
+        method: string;
+        body: any;
+        headers: any;
+    };
+}