cloreai 2.0.0 → 4.0.0

package/package.json

@@ -1,45 +1,44 @@
 {
   "name": "cloreai",
-  "version": "2.0.0",
-  "type": "module",
+  "version": "4.0.0",
   "description": "CLORE.AI API client",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vladpuz/cloreai.git"
-  },
-  "author": "Vladislav Puzyrev",
-  "license": "MIT",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
   "keywords": [
     "cloreai",
     "clore",
     "api"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladpuz/cloreai.git"
+  },
+  "license": "MIT",
+  "author": "Vladislav Puzyrev",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "rimraf dist && tsc --project tsconfig.build.json",
     "check": "npm run typecheck && npm run lint && npm run format",
-    "clean": "rimraf build",
     "format": "prettier --check .",
     "lint": "eslint .",
-    "prepack": "npm run clean && npm run build && npm run check",
+    "prepack": "npm run build && npm run check",
     "prepare": "husky",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "axios": "^1.10.0",
-    "p-queue": "^8.1.0"
+    "p-queue": "^9.1.2"
   },
   "devDependencies": {
-    "@tsconfig/node-lts": "^22.0.2",
-    "@tsconfig/strictest": "^2.0.5",
-    "@types/node": "^24.0.12",
-    "eslint": "^9.30.1",
-    "eslint-config-vladpuz": "^2.0.2",
+    "@tsconfig/node-lts": "^24.0.0",
+    "@tsconfig/node-ts": "^23.6.4",
+    "@tsconfig/strictest": "^2.0.8",
+    "@types/node": "^25.6.0",
+    "eslint": "^10.2.0",
+    "eslint-config-vladpuz": "^4.0.1",
     "husky": "^9.1.7",
-    "prettier": "^3.6.2",
-    "prettier-config-vladpuz": "^1.0.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
+    "prettier": "^3.8.2",
+    "prettier-config-vladpuz": "^3.0.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^6.0.2"
   }
 }

package/build/CloreAI.d.ts

@@ -1,34 +0,0 @@
-import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
-import PQueue from 'p-queue';
-import type { CancelOrderRequestData, CancelOrderResponseData } from './resources/cancelOrder.js';
-import type { CreateOrderRequestData, CreateOrderResponseData } from './resources/createOrder.js';
-import type { MarketplaceResponseData } from './resources/marketplace.js';
-import type { MyOrdersRequestParams, MyOrdersResponseData } from './resources/myOrders.js';
-import type { MyServersResponseData } from './resources/myServers.js';
-import type { PohBalanceResponseData } from './resources/pohBalance.js';
-import type { ServerConfigRequestData, ServerConfigResponseData } from './resources/serverConfig.js';
-import type { SetServerSettingsRequestData, SetServerSettingsResponseData } from './resources/setServerSettings.js';
-import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './resources/setSpotPrice.js';
-import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './resources/spotMarketplace.js';
-import type { WalletsResponseData } from './resources/wallets.js';
-import type { Options } from './types.js';
-import Gigaspot from './Gigaspot.js';
-declare class CloreAI {
-    axios: AxiosInstance;
-    queue: PQueue;
-    queueCreateOrder: PQueue;
-    gigaspot: Gigaspot;
-    constructor(apiKey: string, options?: Options);
-    wallets(config?: AxiosRequestConfig): Promise<WalletsResponseData>;
-    myServers(config?: AxiosRequestConfig): Promise<MyServersResponseData>;
-    serverConfig(data: ServerConfigRequestData, config?: AxiosRequestConfig): Promise<ServerConfigResponseData>;
-    marketplace(config?: AxiosRequestConfig): Promise<MarketplaceResponseData>;
-    myOrders(params?: MyOrdersRequestParams, config?: AxiosRequestConfig): Promise<MyOrdersResponseData>;
-    spotMarketplace(params: SpotMarketplaceRequestParams, config?: AxiosRequestConfig): Promise<SpotMarketplaceResponseData>;
-    setServerSettings(data: SetServerSettingsRequestData, config?: AxiosRequestConfig): Promise<SetServerSettingsResponseData>;
-    setSpotPrice(data: SetSpotPriceRequestData, config?: AxiosRequestConfig): Promise<SetSpotPriceResponseData>;
-    cancelOrder(data: CancelOrderRequestData, config?: AxiosRequestConfig): Promise<CancelOrderResponseData>;
-    createOrder(data: CreateOrderRequestData, config?: AxiosRequestConfig): Promise<CreateOrderResponseData>;
-    pohBalance(config?: AxiosRequestConfig): Promise<PohBalanceResponseData>;
-}
-export default CloreAI;

package/build/CloreAI.js

@@ -1,133 +0,0 @@
-import axios from 'axios';
-import PQueue from 'p-queue';
-import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from './constants.js';
-import { DatabaseError, ExceededError, InvalidApiTokenError, InvalidEndpointError, InvalidInputDataError, OtherError, UnknownError } from './errors.js';
-import { getQueueOptions } from './getQueueOptions.js';
-import Gigaspot from './Gigaspot.js';
-class CloreAI {
-    axios;
-    queue;
-    queueCreateOrder;
-    gigaspot;
-    constructor(apiKey, options = {}) {
-        this.queue = new PQueue({
-            interval: RATE_LIMIT,
-            intervalCap: 1,
-            concurrency: 1,
-            ...options.queueOptions,
-        });
-        this.queueCreateOrder = new PQueue({
-            interval: RATE_LIMIT_CREATE_ORDER,
-            intervalCap: 1,
-            concurrency: 1,
-            ...options.queueOptionsCreateOrder,
-        });
-        this.axios = axios.create({
-            ...options.axiosOptions,
-            baseURL: 'https://api.clore.ai/v1',
-        });
-        this.axios.interceptors.request.use((request) => {
-            request.headers.set('auth', apiKey);
-            return request;
-        });
-        this.axios.interceptors.response.use((response) => {
-            if (response.data.code === statusCodes.NORMAL) {
-                return response;
-            }
-            const errorMessage = response.data.error != null
-                ? `Code "${response.data.code}", error "${response.data.error}"`
-                : `Code "${response.data.code}"`;
-            const axiosErrorParameters = [
-                errorMessage,
-                undefined,
-                response.config,
-                response.request,
-                response,
-            ];
-            switch (response.data.code) {
-                case statusCodes.DATABASE_ERROR:
-                    throw new DatabaseError(...axiosErrorParameters);
-                case statusCodes.INVALID_INPUT_DATA:
-                    throw new InvalidInputDataError(...axiosErrorParameters);
-                case statusCodes.INVALID_API_TOKEN:
-                    throw new InvalidApiTokenError(...axiosErrorParameters);
-                case statusCodes.INVALID_ENDPOINT:
-                    throw new InvalidEndpointError(...axiosErrorParameters);
-                case statusCodes.EXCEEDED:
-                    throw new ExceededError(...axiosErrorParameters);
-                case statusCodes.OTHER:
-                    throw new OtherError(...axiosErrorParameters);
-                default:
-                    throw new UnknownError(...axiosErrorParameters);
-            }
-        });
-        this.gigaspot = new Gigaspot(options, this.axios);
-    }
-    async wallets(config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/wallets', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async myServers(config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/my_servers', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async serverConfig(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/server_config', { ...config, data });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async marketplace(config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/marketplace', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async myOrders(params, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/my_orders', { ...config, params });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async spotMarketplace(params, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/spot_marketplace', { ...config, params });
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-    async setServerSettings(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/set_server_settings', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-    async setSpotPrice(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/set_spot_price', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-    async cancelOrder(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/cancel_order', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-    async createOrder(data, config) {
-        const response = await this.queueCreateOrder.add(async () => {
-            return await this.axios.post('/create_order', data, config);
-        }, getQueueOptions(priorityLevels.HIGHEST, config));
-        return response.data;
-    }
-    async pohBalance(config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.get('/poh_balance', config);
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-        return response.data;
-    }
-}
-export default CloreAI;

package/build/Gigaspot.d.ts

@@ -1,17 +0,0 @@
-import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
-import PQueue from 'p-queue';
-import type { CancelOrdersRequestData, CancelOrdersResponseData } from './resources/cancelOrders.js';
-import type { CreateGigaspotOrdersRequestData, CreateGigaspotOrdersResponseData } from './resources/createGigaspotOrders.js';
-import type { EditGigaspotOrdersRequestData, EditGigaspotOrdersResponseData } from './resources/editGigaspotOrders.js';
-import type { GetGigaspotResponseData } from './resources/getGigaspot.js';
-import type { Options } from './types.js';
-declare class Gigaspot {
-    queue: PQueue;
-    private axios;
-    constructor(options: Options, axios: AxiosInstance);
-    getGigaspot(config?: AxiosRequestConfig): Promise<GetGigaspotResponseData>;
-    createGigaspotOrders(data: CreateGigaspotOrdersRequestData, config?: AxiosRequestConfig): Promise<CreateGigaspotOrdersResponseData>;
-    editGigaspotOrders(data: EditGigaspotOrdersRequestData, config?: AxiosRequestConfig): Promise<EditGigaspotOrdersResponseData>;
-    cancelOrders(data: CancelOrdersRequestData, config?: AxiosRequestConfig): Promise<CancelOrdersResponseData>;
-}
-export default Gigaspot;

package/build/Gigaspot.js

@@ -1,46 +0,0 @@
-import axios from 'axios';
-import PQueue from 'p-queue';
-import { priorityLevels, RATE_LIMIT_GIGASPOT } from './constants.js';
-import { getQueueOptions } from './getQueueOptions.js';
-class Gigaspot {
-    queue;
-    axios;
-    constructor(options, axios) {
-        this.queue = new PQueue({
-            interval: RATE_LIMIT_GIGASPOT,
-            intervalCap: 1,
-            concurrency: 1,
-            ...options.queueOptionsGigaspot,
-        });
-        this.axios = axios;
-    }
-    async getGigaspot(config) {
-        return await this.queue.add(async () => {
-            const response = await this.axios.get('/get_gigaspot', config);
-            const snapshot = await axios.get(response.data.v1_snapshot_url);
-            return {
-                ...response.data,
-                snapshot: snapshot.data,
-            };
-        }, getQueueOptions(priorityLevels.NORMAL, config));
-    }
-    async createGigaspotOrders(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/create_gigaspot_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-    async editGigaspotOrders(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/edit_gigaspot_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-    async cancelOrders(data, config) {
-        const response = await this.queue.add(async () => {
-            return await this.axios.post('/cancel_orders', data, config);
-        }, getQueueOptions(priorityLevels.HIGH, config));
-        return response.data;
-    }
-}
-export default Gigaspot;

package/build/constants.d.ts

@@ -1,21 +0,0 @@
-export declare const RATE_LIMIT = 1800;
-export declare const RATE_LIMIT_CREATE_ORDER = 5000;
-export declare const RATE_LIMIT_GIGASPOT = 1800;
-export declare const gigaspotBaseImages: {
-    UBUNTU: string;
-    HIVEOS: string;
-};
-export declare const statusCodes: {
-    NORMAL: number;
-    DATABASE_ERROR: number;
-    INVALID_INPUT_DATA: number;
-    INVALID_API_TOKEN: number;
-    INVALID_ENDPOINT: number;
-    EXCEEDED: number;
-    OTHER: number;
-};
-export declare const priorityLevels: {
-    NORMAL: number;
-    HIGH: number;
-    HIGHEST: number;
-};

package/build/errors.d.ts

@@ -1,22 +0,0 @@
-import { AxiosError } from 'axios';
-export declare class DatabaseError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidInputDataError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidApiTokenError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class InvalidEndpointError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class ExceededError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class OtherError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}
-export declare class UnknownError extends AxiosError {
-    constructor(...args: ConstructorParameters<typeof AxiosError>);
-}

package/build/errors.js

@@ -1,43 +0,0 @@
-import { AxiosError } from 'axios';
-export class DatabaseError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'DatabaseError';
-    }
-}
-export class InvalidInputDataError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidInputDataError';
-    }
-}
-export class InvalidApiTokenError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidApiTokenError';
-    }
-}
-export class InvalidEndpointError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'InvalidEndpointError';
-    }
-}
-export class ExceededError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'ExceededError';
-    }
-}
-export class OtherError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'OtherError';
-    }
-}
-export class UnknownError extends AxiosError {
-    constructor(...args) {
-        super(...args);
-        this.name = 'UnknownError';
-    }
-}

package/build/getQueueOptions.d.ts

@@ -1,5 +0,0 @@
-import type { AxiosRequestConfig } from 'axios';
-import type { QueueAddOptions } from 'p-queue';
-export declare function getQueueOptions(priority: number, config?: AxiosRequestConfig): QueueAddOptions & {
-    throwOnTimeout: true;
-};

package/build/getQueueOptions.js

@@ -1,15 +0,0 @@
-export function getQueueOptions(priority, config) {
-    const defaultQueueOptions = {
-        throwOnTimeout: true,
-        priority,
-    };
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const signal = config?.signal;
-    if (signal == null) {
-        return defaultQueueOptions;
-    }
-    return {
-        ...defaultQueueOptions,
-        signal,
-    };
-}

package/build/index.d.ts

@@ -1,20 +0,0 @@
-import CloreAI from './CloreAI.js';
-export * from './constants.js';
-export * from './errors.js';
-export type * from './resources/cancelOrder.js';
-export type * from './resources/cancelOrders.js';
-export type * from './resources/createGigaspotOrders.js';
-export type * from './resources/createOrder.js';
-export type * from './resources/editGigaspotOrders.js';
-export type * from './resources/getGigaspot.js';
-export type * from './resources/marketplace.js';
-export type * from './resources/myOrders.js';
-export type * from './resources/myServers.js';
-export type * from './resources/pohBalance.js';
-export type * from './resources/serverConfig.js';
-export type * from './resources/setServerSettings.js';
-export type * from './resources/setSpotPrice.js';
-export type * from './resources/spotMarketplace.js';
-export type * from './resources/wallets.js';
-export type * from './types.js';
-export default CloreAI;

package/build/index.js

@@ -1,4 +0,0 @@
-import CloreAI from './CloreAI.js';
-export * from './constants.js';
-export * from './errors.js';
-export default CloreAI;

package/build/resources/editGigaspotOrders.d.ts

@@ -1,19 +0,0 @@
-import type { ResponseData } from '../types.js';
-export interface EditGigaspotOrdersRequestDataOrderOverclock {
-    pl: number;
-    core_offset?: number;
-    mem_offset?: number;
-    core_lock?: number;
-    mem_lock?: number;
-}
-export interface EditGigaspotOrdersRequestDataOrder {
-    order_id: number;
-    price: number;
-    oc: EditGigaspotOrdersRequestDataOrderOverclock[];
-}
-export type EditGigaspotOrdersRequestData = EditGigaspotOrdersRequestDataOrder[];
-export interface EditGigaspotOrdersResponseData extends ResponseData {
-    success_to_update_ids: number[];
-    failed_to_update_ids: number[];
-    too_low_bid_ids: number[];
-}

package/build/resources/myServers.d.ts

@@ -1,15 +0,0 @@
-import type { Pricing, ResponseData, Specs, Visibility } from '../types.js';
-export interface MyServersResponseDataServer {
-    name: string;
-    connected: boolean;
-    visibility: Visibility;
-    pricing: Pricing;
-    online: boolean;
-    min_spot_pricing: Pricing;
-    init_token: string;
-    specs: Specs;
-}
-export interface MyServersResponseData extends ResponseData {
-    servers: MyServersResponseDataServer[];
-    limit: number;
-}

package/build/resources/setServerSettings.d.ts

@@ -1,11 +0,0 @@
-import type { ResponseData } from '../types.js';
-export interface SetServerSettingsRequestData {
-    'name': string;
-    'availability': boolean;
-    'mrl': number;
-    'on_demand': number;
-    'spot': number;
-    'CLORE-Blockchain_on_demand': number;
-    'CLORE-Blockchain_spot': number;
-}
-export type SetServerSettingsResponseData = ResponseData;

package/build/resources/setSpotPrice.d.ts

@@ -1,17 +0,0 @@
-import type { ResponseData } from '../types.js';
-export interface SetSpotPriceRequestData {
-    order_id: number;
-    desired_price: number;
-}
-export interface SetSpotPriceResponseDataMaxStep extends ResponseData {
-    error: 'exceeded_max_step';
-    max_step: number;
-}
-export interface SetSpotPriceResponseDataTimeToLowering extends ResponseData {
-    error: 'can_lower_every_600_seconds';
-    time_to_lowering: number;
-}
-export interface SetSpotPriceResponseDataNormal extends ResponseData {
-    error: null;
-}
-export type SetSpotPriceResponseData = SetSpotPriceResponseDataMaxStep | SetSpotPriceResponseDataTimeToLowering | SetSpotPriceResponseDataNormal;

package/build/resources/setSpotPrice.js

@@ -1,2 +0,0 @@
-/* RequestData */
-export {};