ccxt-ir 4.10.0 → 4.11.0

package/js/src/src/base/Precise.d.ts

@@ -0,0 +1,42 @@
+import { Str, Int } from './types';
+declare class Precise {
+    decimals: number;
+    integer: bigint;
+    base: any;
+    constructor(number: bigint | string, decimals?: Int);
+    mul(other: Precise): Precise;
+    div(other: Precise, precision?: number): Precise;
+    add(other: Precise): Precise;
+    mod(other: Precise): Precise;
+    sub(other: Precise): Precise;
+    abs(): Precise;
+    neg(): Precise;
+    or(other: Precise): Precise;
+    min(other: Precise): Precise;
+    max(other: Precise): Precise;
+    gt(other: Precise): boolean;
+    ge(other: Precise): boolean;
+    lt(other: Precise): boolean;
+    le(other: Precise): boolean;
+    reduce(): this;
+    equals(other: any): boolean;
+    toString(): string;
+    static stringMul(string1: Str, string2: Str): string;
+    static stringDiv(string1: Str, string2: Str, precision?: number): string;
+    static stringAdd(string1: Str, string2: Str): string;
+    static stringSub(string1: Str, string2: Str): string;
+    static stringAbs(string: Str): string;
+    static stringNeg(string: Str): string;
+    static stringMod(string1: Str, string2: Str): string;
+    static stringOr(string1: Str, string2: Str): string;
+    static stringEquals(string1: Str, string2: Str): boolean;
+    static stringEq(string1: Str, string2: Str): boolean;
+    static stringMin(string1: Str, string2: Str): string;
+    static stringMax(string1: Str, string2: Str): string;
+    static stringGt(string1: Str, string2: Str): boolean;
+    static stringGe(string1: Str, string2: Str): boolean;
+    static stringLt(string1: Str, string2: Str): boolean;
+    static stringLe(string1: Str, string2: Str): boolean;
+}
+export default Precise;
+export { Precise };

package/js/src/src/base/Precise.js

@@ -0,0 +1,275 @@
+// ----------------------------------------------------------------------------
+
+// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
+// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
+// EDIT THE CORRESPONDENT .ts FILE INSTEAD
+
+const zero = BigInt(0);
+const minusOne = BigInt(-1);
+const base = BigInt(10);
+class Precise {
+    constructor(number, decimals = undefined) {
+        this.base = undefined;
+        if (decimals === undefined) {
+            let modifier = 0;
+            number = number.toLowerCase();
+            if (number.indexOf('e') > -1) {
+                let modifierString = '0';
+                [number, modifierString] = number.split('e');
+                modifier = parseInt(modifierString);
+            }
+            const decimalIndex = number.indexOf('.');
+            this.decimals = (decimalIndex > -1) ? number.length - decimalIndex - 1 : 0;
+            const integerString = number.replace('.', '');
+            this.integer = BigInt(integerString);
+            this.decimals = this.decimals - modifier;
+        }
+        else {
+            this.integer = number;
+            this.decimals = decimals;
+        }
+    }
+    mul(other) {
+        // other must be another instance of Precise
+        const integerResult = this.integer * other.integer;
+        return new Precise(integerResult, this.decimals + other.decimals);
+    }
+    div(other, precision = 18) {
+        const distance = precision - this.decimals + other.decimals;
+        let numerator;
+        if (distance === 0) {
+            numerator = this.integer;
+        }
+        else if (distance < 0) {
+            const exponent = base ** BigInt(-distance);
+            numerator = this.integer / exponent;
+        }
+        else {
+            const exponent = base ** BigInt(distance);
+            numerator = this.integer * exponent;
+        }
+        const result = numerator / other.integer;
+        return new Precise(result, precision);
+    }
+    add(other) {
+        if (this.decimals === other.decimals) {
+            const integerResult = this.integer + other.integer;
+            return new Precise(integerResult, this.decimals);
+        }
+        else {
+            const [smaller, bigger] = (this.decimals > other.decimals) ? [other, this] : [this, other];
+            const exponent = bigger.decimals - smaller.decimals;
+            const normalised = smaller.integer * (base ** BigInt(exponent));
+            const result = normalised + bigger.integer;
+            return new Precise(result, bigger.decimals);
+        }
+    }
+    mod(other) {
+        const rationizerNumerator = Math.max(-this.decimals + other.decimals, 0);
+        const numerator = this.integer * (base ** BigInt(rationizerNumerator));
+        const rationizerDenominator = Math.max(-other.decimals + this.decimals, 0);
+        const denominator = other.integer * (base ** BigInt(rationizerDenominator));
+        const result = numerator % denominator;
+        return new Precise(result, rationizerDenominator + other.decimals);
+    }
+    sub(other) {
+        const negative = new Precise(-other.integer, other.decimals);
+        return this.add(negative);
+    }
+    abs() {
+        return new Precise(this.integer < 0 ? this.integer * minusOne : this.integer, this.decimals);
+    }
+    neg() {
+        return new Precise(-this.integer, this.decimals);
+    }
+    or(other) {
+        const integerResult = this.integer | other.integer;
+        return new Precise(integerResult, this.decimals);
+    }
+    min(other) {
+        return this.lt(other) ? this : other;
+    }
+    max(other) {
+        return this.gt(other) ? this : other;
+    }
+    gt(other) {
+        const sum = this.sub(other);
+        return sum.integer > 0;
+    }
+    ge(other) {
+        const sum = this.sub(other);
+        return sum.integer >= 0;
+    }
+    lt(other) {
+        return other.gt(this);
+    }
+    le(other) {
+        return other.ge(this);
+    }
+    reduce() {
+        const string = this.integer.toString();
+        const start = string.length - 1;
+        if (start === 0) {
+            if (string === '0') {
+                this.decimals = 0;
+            }
+            return this;
+        }
+        let i;
+        for (i = start; i >= 0; i--) {
+            if (string.charAt(i) !== '0') {
+                break;
+            }
+        }
+        const difference = start - i;
+        if (difference === 0) {
+            return this;
+        }
+        this.decimals -= difference;
+        this.integer = BigInt(string.slice(0, i + 1));
+    }
+    equals(other) {
+        this.reduce();
+        other.reduce();
+        return (this.decimals === other.decimals) && (this.integer === other.integer);
+    }
+    toString() {
+        this.reduce();
+        let sign;
+        let abs;
+        if (this.integer < 0) {
+            sign = '-';
+            abs = -this.integer;
+        }
+        else {
+            sign = '';
+            abs = this.integer;
+        }
+        const integerArray = Array.from(abs.toString(Number(base)).padStart(this.decimals, '0'));
+        const index = integerArray.length - this.decimals;
+        let item;
+        if (index === 0) {
+            // if we are adding to the front
+            item = '0.';
+        }
+        else if (this.decimals < 0) {
+            item = '0'.repeat(-this.decimals);
+        }
+        else if (this.decimals === 0) {
+            item = '';
+        }
+        else {
+            item = '.';
+        }
+        integerArray.splice(index, 0, item);
+        return sign + integerArray.join('');
+    }
+    static stringMul(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).mul(new Precise(string2)).toString();
+    }
+    static stringDiv(string1, string2, precision = 18) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        const string2Precise = new Precise(string2);
+        if (string2Precise.integer === zero) {
+            return undefined;
+        }
+        return (new Precise(string1)).div(string2Precise, precision).toString();
+    }
+    static stringAdd(string1, string2) {
+        if ((string1 === undefined) && (string2 === undefined)) {
+            return undefined;
+        }
+        if (string1 === undefined) {
+            return string2;
+        }
+        else if (string2 === undefined) {
+            return string1;
+        }
+        return (new Precise(string1)).add(new Precise(string2)).toString();
+    }
+    static stringSub(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).sub(new Precise(string2)).toString();
+    }
+    static stringAbs(string) {
+        if (string === undefined) {
+            return undefined;
+        }
+        return (new Precise(string)).abs().toString();
+    }
+    static stringNeg(string) {
+        if (string === undefined) {
+            return undefined;
+        }
+        return (new Precise(string)).neg().toString();
+    }
+    static stringMod(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).mod(new Precise(string2)).toString();
+    }
+    static stringOr(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).or(new Precise(string2)).toString();
+    }
+    static stringEquals(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).equals(new Precise(string2));
+    }
+    static stringEq(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).equals(new Precise(string2));
+    }
+    static stringMin(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).min(new Precise(string2)).toString();
+    }
+    static stringMax(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).max(new Precise(string2)).toString();
+    }
+    static stringGt(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).gt(new Precise(string2));
+    }
+    static stringGe(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).ge(new Precise(string2));
+    }
+    static stringLt(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).lt(new Precise(string2));
+    }
+    static stringLe(string1, string2) {
+        if ((string1 === undefined) || (string2 === undefined)) {
+            return undefined;
+        }
+        return (new Precise(string1)).le(new Precise(string2));
+    }
+}
+export default Precise;
+export { Precise };

package/js/src/src/base/errors.d.ts

@@ -0,0 +1,168 @@
+declare class BaseError extends Error {
+    constructor(message: string);
+}
+declare class ExchangeError extends BaseError {
+    constructor(message: string);
+}
+declare class AuthenticationError extends ExchangeError {
+    constructor(message: string);
+}
+declare class PermissionDenied extends AuthenticationError {
+    constructor(message: string);
+}
+declare class AccountNotEnabled extends PermissionDenied {
+    constructor(message: string);
+}
+declare class AccountSuspended extends AuthenticationError {
+    constructor(message: string);
+}
+declare class ArgumentsRequired extends ExchangeError {
+    constructor(message: string);
+}
+declare class BadRequest extends ExchangeError {
+    constructor(message: string);
+}
+declare class BadSymbol extends BadRequest {
+    constructor(message: string);
+}
+declare class OperationRejected extends ExchangeError {
+    constructor(message: string);
+}
+declare class NoChange extends OperationRejected {
+    constructor(message: string);
+}
+declare class MarginModeAlreadySet extends NoChange {
+    constructor(message: string);
+}
+declare class MarketClosed extends OperationRejected {
+    constructor(message: string);
+}
+declare class ManualInteractionNeeded extends OperationRejected {
+    constructor(message: string);
+}
+declare class RestrictedLocation extends OperationRejected {
+    constructor(message: string);
+}
+declare class InsufficientFunds extends ExchangeError {
+    constructor(message: string);
+}
+declare class InvalidAddress extends ExchangeError {
+    constructor(message: string);
+}
+declare class AddressPending extends InvalidAddress {
+    constructor(message: string);
+}
+declare class InvalidOrder extends ExchangeError {
+    constructor(message: string);
+}
+declare class OrderNotFound extends InvalidOrder {
+    constructor(message: string);
+}
+declare class OrderNotCached extends InvalidOrder {
+    constructor(message: string);
+}
+declare class OrderImmediatelyFillable extends InvalidOrder {
+    constructor(message: string);
+}
+declare class OrderNotFillable extends InvalidOrder {
+    constructor(message: string);
+}
+declare class DuplicateOrderId extends InvalidOrder {
+    constructor(message: string);
+}
+declare class ContractUnavailable extends InvalidOrder {
+    constructor(message: string);
+}
+declare class NotSupported extends ExchangeError {
+    constructor(message: string);
+}
+declare class InvalidProxySettings extends ExchangeError {
+    constructor(message: string);
+}
+declare class ExchangeClosedByUser extends ExchangeError {
+    constructor(message: string);
+}
+declare class OperationFailed extends BaseError {
+    constructor(message: string);
+}
+declare class NetworkError extends OperationFailed {
+    constructor(message: string);
+}
+declare class DDoSProtection extends NetworkError {
+    constructor(message: string);
+}
+declare class RateLimitExceeded extends NetworkError {
+    constructor(message: string);
+}
+declare class ExchangeNotAvailable extends NetworkError {
+    constructor(message: string);
+}
+declare class OnMaintenance extends ExchangeNotAvailable {
+    constructor(message: string);
+}
+declare class InvalidNonce extends NetworkError {
+    constructor(message: string);
+}
+declare class ChecksumError extends InvalidNonce {
+    constructor(message: string);
+}
+declare class RequestTimeout extends NetworkError {
+    constructor(message: string);
+}
+declare class BadResponse extends OperationFailed {
+    constructor(message: string);
+}
+declare class NullResponse extends BadResponse {
+    constructor(message: string);
+}
+declare class CancelPending extends OperationFailed {
+    constructor(message: string);
+}
+declare class UnsubscribeError extends BaseError {
+    constructor(message: string);
+}
+export { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, RestrictedLocation, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError };
+declare const _default: {
+    BaseError: typeof BaseError;
+    ExchangeError: typeof ExchangeError;
+    AuthenticationError: typeof AuthenticationError;
+    PermissionDenied: typeof PermissionDenied;
+    AccountNotEnabled: typeof AccountNotEnabled;
+    AccountSuspended: typeof AccountSuspended;
+    ArgumentsRequired: typeof ArgumentsRequired;
+    BadRequest: typeof BadRequest;
+    BadSymbol: typeof BadSymbol;
+    OperationRejected: typeof OperationRejected;
+    NoChange: typeof NoChange;
+    MarginModeAlreadySet: typeof MarginModeAlreadySet;
+    MarketClosed: typeof MarketClosed;
+    ManualInteractionNeeded: typeof ManualInteractionNeeded;
+    RestrictedLocation: typeof RestrictedLocation;
+    InsufficientFunds: typeof InsufficientFunds;
+    InvalidAddress: typeof InvalidAddress;
+    AddressPending: typeof AddressPending;
+    InvalidOrder: typeof InvalidOrder;
+    OrderNotFound: typeof OrderNotFound;
+    OrderNotCached: typeof OrderNotCached;
+    OrderImmediatelyFillable: typeof OrderImmediatelyFillable;
+    OrderNotFillable: typeof OrderNotFillable;
+    DuplicateOrderId: typeof DuplicateOrderId;
+    ContractUnavailable: typeof ContractUnavailable;
+    NotSupported: typeof NotSupported;
+    InvalidProxySettings: typeof InvalidProxySettings;
+    ExchangeClosedByUser: typeof ExchangeClosedByUser;
+    OperationFailed: typeof OperationFailed;
+    NetworkError: typeof NetworkError;
+    DDoSProtection: typeof DDoSProtection;
+    RateLimitExceeded: typeof RateLimitExceeded;
+    ExchangeNotAvailable: typeof ExchangeNotAvailable;
+    OnMaintenance: typeof OnMaintenance;
+    InvalidNonce: typeof InvalidNonce;
+    ChecksumError: typeof ChecksumError;
+    RequestTimeout: typeof RequestTimeout;
+    BadResponse: typeof BadResponse;
+    NullResponse: typeof NullResponse;
+    CancelPending: typeof CancelPending;
+    UnsubscribeError: typeof UnsubscribeError;
+};
+export default _default;