ccxt 4.5.17 → 4.5.19

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/subaccounts/perpetual_position.d.ts

@@ -0,0 +1,34 @@
+import * as _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * PerpetualPositions are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+export interface PerpetualPosition {
+    /** The `Id` of the `Perpetual`. */
+    perpetualId: number;
+    /** The size of the position in base quantums. */
+    quantums: Uint8Array;
+    /**
+     * The funding_index of the `Perpetual` the last time this position was
+     * settled.
+     */
+    fundingIndex: Uint8Array;
+    /** The quote_balance of the `Perpetual`. */
+    quoteBalance: Uint8Array;
+}
+/**
+ * PerpetualPositions are an account’s positions of a `Perpetual`.
+ * Therefore they hold any information needed to trade perpetuals.
+ */
+export interface PerpetualPositionSDKType {
+    perpetual_id: number;
+    quantums: Uint8Array;
+    funding_index: Uint8Array;
+    quote_balance: Uint8Array;
+}
+export declare const PerpetualPosition: {
+    encode(message: PerpetualPosition, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PerpetualPosition;
+    fromPartial(object: DeepPartial<PerpetualPosition>): PerpetualPosition;
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/subaccounts/perpetual_position.js

@@ -0,0 +1,60 @@
+import * as _m0 from "protobufjs/minimal.js";
+function createBasePerpetualPosition() {
+    return {
+        perpetualId: 0,
+        quantums: new Uint8Array(),
+        fundingIndex: new Uint8Array(),
+        quoteBalance: new Uint8Array()
+    };
+}
+export const PerpetualPosition = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.perpetualId !== 0) {
+            writer.uint32(8).uint32(message.perpetualId);
+        }
+        if (message.quantums.length !== 0) {
+            writer.uint32(18).bytes(message.quantums);
+        }
+        if (message.fundingIndex.length !== 0) {
+            writer.uint32(26).bytes(message.fundingIndex);
+        }
+        if (message.quoteBalance.length !== 0) {
+            writer.uint32(34).bytes(message.quoteBalance);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePerpetualPosition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.perpetualId = reader.uint32();
+                    break;
+                case 2:
+                    message.quantums = reader.bytes();
+                    break;
+                case 3:
+                    message.fundingIndex = reader.bytes();
+                    break;
+                case 4:
+                    message.quoteBalance = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePerpetualPosition();
+        message.perpetualId = object.perpetualId ?? 0;
+        message.quantums = object.quantums ?? new Uint8Array();
+        message.fundingIndex = object.fundingIndex ?? new Uint8Array();
+        message.quoteBalance = object.quoteBalance ?? new Uint8Array();
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/subaccounts/subaccount.d.ts

@@ -0,0 +1,62 @@
+import { AssetPosition, AssetPositionSDKType } from "./asset_position.js";
+import { PerpetualPosition, PerpetualPositionSDKType } from "./perpetual_position.js";
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/** SubaccountId defines a unique identifier for a Subaccount. */
+export interface SubaccountId {
+    /** The address of the wallet that owns this subaccount. */
+    owner: string;
+    /**
+     * The unique number of this subaccount for the owner.
+     * Currently limited to 128*1000 subaccounts per owner.
+     */
+    number: number;
+}
+/** SubaccountId defines a unique identifier for a Subaccount. */
+export interface SubaccountIdSDKType {
+    owner: string;
+    number: number;
+}
+/**
+ * Subaccount defines a single sub-account for a given address.
+ * Subaccounts are uniquely indexed by a subaccountNumber/owner pair.
+ */
+export interface Subaccount {
+    /** The Id of the Subaccount */
+    id?: SubaccountId;
+    /**
+     * All `AssetPosition`s associated with this subaccount.
+     * Always sorted ascending by `asset_id`.
+     */
+    assetPositions: AssetPosition[];
+    /**
+     * All `PerpetualPosition`s associated with this subaccount.
+     * Always sorted ascending by `perpetual_id.
+     */
+    perpetualPositions: PerpetualPosition[];
+    /**
+     * Set by the owner. If true, then margin trades can be made in this
+     * subaccount.
+     */
+    marginEnabled: boolean;
+}
+/**
+ * Subaccount defines a single sub-account for a given address.
+ * Subaccounts are uniquely indexed by a subaccountNumber/owner pair.
+ */
+export interface SubaccountSDKType {
+    id?: SubaccountIdSDKType;
+    asset_positions: AssetPositionSDKType[];
+    perpetual_positions: PerpetualPositionSDKType[];
+    margin_enabled: boolean;
+}
+export declare const SubaccountId: {
+    encode(message: SubaccountId, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubaccountId;
+    fromPartial(object: DeepPartial<SubaccountId>): SubaccountId;
+};
+export declare const Subaccount: {
+    encode(message: Subaccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Subaccount;
+    fromPartial(object: DeepPartial<Subaccount>): Subaccount;
+};

package/js/src/static_dependencies/dydx-v4-client/dydxprotocol/subaccounts/subaccount.js

@@ -0,0 +1,105 @@
+import { AssetPosition } from "./asset_position.js";
+import { PerpetualPosition } from "./perpetual_position.js";
+import _m0 from "protobufjs/minimal.js";
+function createBaseSubaccountId() {
+    return {
+        owner: "",
+        number: 0
+    };
+}
+export const SubaccountId = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.number !== 0) {
+            writer.uint32(16).uint32(message.number);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSubaccountId();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.number = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSubaccountId();
+        message.owner = object.owner ?? "";
+        message.number = object.number ?? 0;
+        return message;
+    }
+};
+function createBaseSubaccount() {
+    return {
+        id: undefined,
+        assetPositions: [],
+        perpetualPositions: [],
+        marginEnabled: false
+    };
+}
+export const Subaccount = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== undefined) {
+            SubaccountId.encode(message.id, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.assetPositions) {
+            AssetPosition.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.perpetualPositions) {
+            PerpetualPosition.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.marginEnabled === true) {
+            writer.uint32(32).bool(message.marginEnabled);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSubaccount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = SubaccountId.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.assetPositions.push(AssetPosition.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.perpetualPositions.push(PerpetualPosition.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.marginEnabled = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSubaccount();
+        message.id = object.id !== undefined && object.id !== null ? SubaccountId.fromPartial(object.id) : undefined;
+        message.assetPositions = object.assetPositions?.map(e => AssetPosition.fromPartial(e)) || [];
+        message.perpetualPositions = object.perpetualPositions?.map(e => PerpetualPosition.fromPartial(e)) || [];
+        message.marginEnabled = object.marginEnabled ?? false;
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/google/protobuf/any.d.ts

@@ -0,0 +1,207 @@
+import _m0 from "protobufjs/minimal.js";
+import { DeepPartial } from "../../helpers.js";
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := ptypes.MarshalAny(foo)
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface Any {
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     */
+    typeUrl: string;
+    /** Must be a valid serialized protocol buffer of the above specified type. */
+    value: Uint8Array;
+}
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := ptypes.MarshalAny(foo)
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ */
+export interface AnySDKType {
+    type_url: string;
+    value: Uint8Array;
+}
+export declare const Any: {
+    encode(message: Any, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Any;
+    fromPartial(object: DeepPartial<Any>): Any;
+};

package/js/src/static_dependencies/dydx-v4-client/google/protobuf/any.js

@@ -0,0 +1,44 @@
+import _m0 from "protobufjs/minimal.js";
+function createBaseAny() {
+    return {
+        typeUrl: "",
+        value: new Uint8Array()
+    };
+}
+export const Any = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.typeUrl !== "") {
+            writer.uint32(10).string(message.typeUrl);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAny();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.typeUrl = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAny();
+        message.typeUrl = object.typeUrl ?? "";
+        message.value = object.value ?? new Uint8Array();
+        return message;
+    }
+};

package/js/src/static_dependencies/dydx-v4-client/helpers.d.ts

@@ -0,0 +1,82 @@
+/**
+* This file and any referenced files were automatically generated by @osmonauts/telescope@0.86.0
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or yarn proto command to regenerate this bundle.
+*/
+import Long from './long/index.cjs';
+export { Long };
+export declare function bytesFromBase64(b64: string): Uint8Array;
+export declare function base64FromBytes(arr: Uint8Array): string;
+export interface AminoHeight {
+    readonly revision_number?: string;
+    readonly revision_height?: string;
+}
+export declare function omitDefault<T extends string | number | Long>(input: T): T | undefined;
+interface Duration {
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     */
+    seconds: Long;
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     */
+    nanos: number;
+}
+export declare function toDuration(duration: string): Duration;
+export declare function fromDuration(duration: Duration): string;
+export declare function isSet(value: any): boolean;
+export declare function isObject(value: any): boolean;
+export interface PageRequest {
+    key: Uint8Array;
+    offset: Long;
+    limit: Long;
+    countTotal: boolean;
+    reverse: boolean;
+}
+export interface PageRequestParams {
+    "pagination.key"?: string;
+    "pagination.offset"?: string;
+    "pagination.limit"?: string;
+    "pagination.count_total"?: boolean;
+    "pagination.reverse"?: boolean;
+}
+export interface Params {
+    params: PageRequestParams;
+}
+export declare const setPaginationParams: (options: Params, pagination?: PageRequest) => Params;
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
+export interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     */
+    seconds: Long;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare function toTimestamp(date: Date): Timestamp;
+export declare function fromTimestamp(t: Timestamp): Date;
+export declare function fromJsonTimestamp(o: any): Timestamp;