@himalaya-quant/ctrader-x 0.0.7

package/src/classes/client.ts

@@ -0,0 +1,102 @@
+import { CTraderConnection } from '@reiryoku/ctrader-layer';
+import { ILogger, Logger } from './logger';
+import { AuthenticationManager } from './managers/authentication/authentication.manager';
+import { Config } from '../config/config';
+import { ConnectionError } from './errors/connection.error';
+import { cTraderXError } from './models/ctrader-x-error.model';
+import { IConfiguration } from './models/client-configuration.model';
+import { SymbolsManager } from './managers/symbols/symbols.manager';
+import { ClientNotConnectedError } from './errors/client-not-connected.error';
+import { SymbolsUpdatesManager } from './managers/symbols/symbols-updates.manager';
+
+export class cTraderX {
+    private readonly port = 5035;
+    private readonly host: string;
+    private readonly logger: ILogger;
+    private readonly connection: CTraderConnection;
+
+    private readonly symbolsManager: SymbolsManager;
+    private readonly authManager: AuthenticationManager;
+    private readonly symbolsUpdatesManager: SymbolsUpdatesManager;
+
+    private isConnected = false;
+
+    constructor(config?: IConfiguration) {
+        this.host = config?.live
+            ? `live.ctraderapi.com`
+            : `demo.ctraderapi.com`;
+        this.logger = config?.logger || new Logger();
+
+        const credentials = {
+            clientId: config?.clientId || Config.SPOTWARE_CLIENT_ID,
+            accessToken: config?.accessToken || Config.SPOTWARE_ACCESS_TOKEN,
+            clientSecret: config?.clientSecret || Config.SPOTWARE_CLIENT_SECRET,
+            ctidTraderAccountId:
+                config?.ctidTraderAccountId ||
+                Config.SPOTWARE_CTID_TRADER_ACCOUNT_ID,
+        };
+
+        this.connection = new CTraderConnection({
+            host: this.host,
+            port: this.port,
+        });
+
+        this.symbolsManager = new SymbolsManager(
+            credentials,
+            this.connection,
+            this.logger,
+        );
+        this.authManager = new AuthenticationManager(
+            credentials,
+            this.connection,
+            this.logger,
+        );
+        this.symbolsUpdatesManager = new SymbolsUpdatesManager(
+            credentials,
+            this.connection,
+            this.logger,
+            this.symbolsManager,
+        );
+    }
+
+    get symbols() {
+        this.ensureConnectedOrThrow();
+        return this.symbolsManager;
+    }
+
+    get symbolsUpdates() {
+        this.ensureConnectedOrThrow();
+        return this.symbolsUpdatesManager;
+    }
+
+    disconnect() {
+        this.connection.close();
+    }
+
+    async connect(): Promise<void> {
+        if (this.isConnected) return;
+        try {
+            await this.connection.open();
+            await this.authManager.authenticateApp();
+            await this.authManager.authenticateUser();
+            this.isConnected = true;
+            this.sendHeartbeat();
+        } catch (e) {
+            const message = cTraderXError.getMessageError(e);
+            this.logger.error(`Error opening connection: ${message}`);
+            throw new ConnectionError(message);
+        }
+    }
+
+    private sendHeartbeat() {
+        if (!this.isConnected) return;
+        this.connection.sendHeartbeat();
+        setTimeout(() => {
+            this.sendHeartbeat();
+        }, 1000 * 9);
+    }
+
+    private ensureConnectedOrThrow() {
+        if (!this.isConnected) throw new ClientNotConnectedError();
+    }
+}

package/src/classes/errors/client-not-connected.error.ts

@@ -0,0 +1,7 @@
+import { cTraderXError } from '../models/ctrader-x-error.model';
+
+export class ClientNotConnectedError extends cTraderXError {
+    constructor() {
+        super(`Client not connected error`);
+    }
+}

package/src/classes/errors/connection.error.ts

@@ -0,0 +1,7 @@
+import { cTraderXError } from '../models/ctrader-x-error.model';
+
+export class ConnectionError extends cTraderXError {
+    constructor(message: string) {
+        super(`Connection error: ${message}`);
+    }
+}

package/src/classes/logger.ts

@@ -0,0 +1,26 @@
+import { Config } from '../config/config';
+
+export interface ILogger {
+    debug(message: string): void;
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+
+export class Logger implements ILogger{
+    debug(message: string) {
+        if (Config.DEBUG_LOGS) console.log(`🐛 ${message}`);
+    }
+
+    log(message: string) {
+        console.log(`ℹ️ ${message}`);
+    }
+
+    error(message: string) {
+        console.log(`❌ ${message}`);
+    }
+
+    warn(message: string) {
+        console.log(`⚠️ ${message}`);
+    }
+}

package/src/classes/managers/authentication/authentication.manager.test.ts

@@ -0,0 +1,187 @@
+// tests/managers/authentication.manager.test.ts
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { CTraderConnection } from '@reiryoku/ctrader-layer';
+import { Config } from '../../../config/config';
+import { ApplicationAuthenticationError } from './errors/application-auth.error';
+import { UserAuthenticationError } from './errors/user-auth.error';
+import { Logger } from '../../logger';
+import { AuthenticationManager } from './authentication.manager';
+
+describe('AuthenticationManager - Integration Tests', () => {
+    let connection: CTraderConnection;
+    let authManager: AuthenticationManager;
+    let logger: Logger;
+
+    const host = 'demo.ctraderapi.com';
+    const port = 5035;
+
+    beforeAll(async () => {
+        logger = new Logger();
+
+        connection = new CTraderConnection({
+            host,
+            port,
+        });
+
+        const credentials = {
+            clientId: Config.SPOTWARE_CLIENT_ID,
+            clientSecret: Config.SPOTWARE_CLIENT_SECRET,
+            accessToken: Config.SPOTWARE_ACCESS_TOKEN,
+            ctidTraderAccountId: Config.SPOTWARE_CTID_TRADER_ACCOUNT_ID,
+        };
+
+        authManager = new AuthenticationManager(
+            credentials,
+            connection,
+            logger,
+        );
+
+        // Apri la connessione prima dei test
+        await connection.open();
+    });
+
+    afterAll(async () => {
+        // Chiudi la connessione dopo i test
+        await connection.close();
+    });
+
+    describe('authenticateApp', () => {
+        it('should authenticate application successfully', async () => {
+            await expect(authManager.authenticateApp()).resolves.not.toThrow();
+        });
+
+        it('should throw ApplicationAuthenticationError with invalid credentials', async () => {
+            const invalidConnection = new CTraderConnection({
+                host,
+                port,
+            });
+
+            await invalidConnection.open();
+
+            const invalidCredentials = {
+                clientId: 'invalid_client_id',
+                clientSecret: 'invalid_client_secret',
+                accessToken: Config.SPOTWARE_ACCESS_TOKEN,
+                ctidTraderAccountId: Config.SPOTWARE_CTID_TRADER_ACCOUNT_ID,
+            };
+
+            const invalidAuthManager = new AuthenticationManager(
+                invalidCredentials,
+                invalidConnection,
+                logger,
+            );
+
+            await expect(invalidAuthManager.authenticateApp()).rejects.toThrow(
+                ApplicationAuthenticationError,
+            );
+
+            await invalidConnection.close();
+        });
+    });
+
+    describe('authenticateUser', () => {
+        it('should authenticate user successfully after app authentication', async () => {
+            // Prima autentica l'app
+            // await authManager.authenticateApp();
+
+            // Poi autentica l'utente
+            await expect(authManager.authenticateUser()).resolves.not.toThrow();
+        });
+
+        it('should throw UserAuthenticationError with invalid access token', async () => {
+            const invalidConnection = new CTraderConnection({
+                host,
+                port,
+            });
+
+            await invalidConnection.open();
+
+            const validAppCredentials = {
+                clientId: Config.SPOTWARE_CLIENT_ID,
+                clientSecret: Config.SPOTWARE_CLIENT_SECRET,
+                accessToken: 'invalid_access_token',
+                ctidTraderAccountId: Config.SPOTWARE_CTID_TRADER_ACCOUNT_ID,
+            };
+
+            const invalidAuthManager = new AuthenticationManager(
+                validAppCredentials,
+                invalidConnection,
+                logger,
+            );
+
+            // Autentica prima l'app (che dovrebbe funzionare)
+            await invalidAuthManager.authenticateApp();
+
+            // Poi prova ad autenticare l'utente (che dovrebbe fallire)
+            await expect(invalidAuthManager.authenticateUser()).rejects.toThrow(
+                UserAuthenticationError,
+            );
+
+            await invalidConnection.close();
+        });
+
+        it('should throw UserAuthenticationError with invalid ctidTraderAccountId', async () => {
+            const invalidConnection = new CTraderConnection({
+                host,
+                port,
+            });
+
+            await invalidConnection.open();
+
+            const invalidCredentials = {
+                clientId: Config.SPOTWARE_CLIENT_ID,
+                clientSecret: Config.SPOTWARE_CLIENT_SECRET,
+                accessToken: Config.SPOTWARE_ACCESS_TOKEN,
+                ctidTraderAccountId: 999999999, // ID non valido
+            };
+
+            const invalidAuthManager = new AuthenticationManager(
+                invalidCredentials,
+                invalidConnection,
+                logger,
+            );
+
+            await invalidAuthManager.authenticateApp();
+
+            await expect(invalidAuthManager.authenticateUser()).rejects.toThrow(
+                UserAuthenticationError,
+            );
+
+            await invalidConnection.close();
+        });
+    });
+
+    describe('Full authentication flow', () => {
+        it('should complete full authentication flow successfully', async () => {
+            const newConnection = new CTraderConnection({
+                host,
+                port,
+            });
+
+            await newConnection.open();
+
+            const credentials = {
+                clientId: Config.SPOTWARE_CLIENT_ID,
+                clientSecret: Config.SPOTWARE_CLIENT_SECRET,
+                accessToken: Config.SPOTWARE_ACCESS_TOKEN,
+                ctidTraderAccountId: Config.SPOTWARE_CTID_TRADER_ACCOUNT_ID,
+            };
+
+            const newAuthManager = new AuthenticationManager(
+                credentials,
+                newConnection,
+                logger,
+            );
+
+            // Test del flusso completo
+            await expect(
+                newAuthManager.authenticateApp(),
+            ).resolves.not.toThrow();
+            await expect(
+                newAuthManager.authenticateUser(),
+            ).resolves.not.toThrow();
+
+            await newConnection.close();
+        });
+    });
+});

package/src/classes/managers/authentication/authentication.manager.ts

@@ -0,0 +1,65 @@
+import { CTraderConnection } from '@reiryoku/ctrader-layer';
+
+import { ILogger } from '../../logger';
+import { BaseManager } from '../models/base.manager';
+import { ICredentials } from '../models/credentials.model';
+import { UserAuthenticationError } from './errors/user-auth.error';
+import { ApplicationAuthenticationError } from './errors/application-auth.error';
+import { ProtoOAAccountAuthReq } from '../../../models/proto/messages/authentication/ProtoOAAccountAuthReq';
+import { ProtoOAApplicationAuthReq } from '../../../models/proto/messages/authentication/ProtoOAApplicationAuthReq';
+
+export class AuthenticationManager extends BaseManager {
+    constructor(
+        protected readonly credentials: ICredentials,
+        protected readonly connection: CTraderConnection,
+        protected readonly logger: ILogger,
+    ) {
+        super();
+    }
+
+    async authenticateApp() {
+        try {
+            this.logCallAttempt(this.authenticateApp);
+
+            const payload: ProtoOAApplicationAuthReq = {
+                clientId: this.credentials.clientId,
+                clientSecret: this.credentials.clientSecret,
+            };
+            await this.connection.sendCommand(
+                ProtoOAApplicationAuthReq.name,
+                payload,
+            );
+
+            this.logCallAttemptSuccess(this.authenticateApp);
+        } catch (e) {
+            throw this.handleCTraderCallError(
+                e,
+                this.authenticateApp,
+                new ApplicationAuthenticationError(e),
+            );
+        }
+    }
+
+    async authenticateUser() {
+        try {
+            this.logCallAttempt(this.authenticateUser);
+
+            const payload: ProtoOAAccountAuthReq = {
+                accessToken: this.credentials.accessToken,
+                ctidTraderAccountId: this.credentials.ctidTraderAccountId,
+            };
+            await this.connection.sendCommand(
+                ProtoOAAccountAuthReq.name,
+                payload,
+            );
+
+            this.logCallAttemptSuccess(this.authenticateUser);
+        } catch (e) {
+            throw this.handleCTraderCallError(
+                e,
+                this.authenticateUser,
+                new UserAuthenticationError(e),
+            );
+        }
+    }
+}

package/src/classes/managers/authentication/errors/application-auth.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class ApplicationAuthenticationError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Application authentication error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/authentication/errors/user-auth.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class UserAuthenticationError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `User authentication error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/models/base.manager.ts

@@ -0,0 +1,50 @@
+import { cTraderXError } from '../../models/ctrader-x-error.model';
+import { ILogger } from '../../logger';
+import { CTraderConnection } from '@reiryoku/ctrader-layer';
+import { ICredentials } from './credentials.model';
+import { ProtoOAErrorRes } from '../../../models/proto/models/ProtoOAErrorRes';
+
+export abstract class BaseManager {
+    protected readonly logger: ILogger;
+    protected readonly credentials: ICredentials;
+    protected readonly connection: CTraderConnection;
+
+    protected logCallAttempt(method: Function, extra?: Record<string, any>) {
+        if (extra) {
+            this.logger.debug(
+                `Attempting ${method.name} call: ${JSON.stringify(extra)}`,
+            );
+        } else {
+            this.logger.debug(`Attempting ${method.name} call`);
+        }
+    }
+
+    protected logCallAttemptSuccess(
+        method: Function,
+        extra?: Record<string, any>,
+    ) {
+        if (extra) {
+            this.logger.debug(
+                `Call attempt to ${method.name} succeeded: ${JSON.stringify(extra)}`,
+            );
+        } else {
+            this.logger.debug(`Call attempt to ${method.name} succeeded`);
+        }
+    }
+
+    protected logCallAttemptFailure(method: Function, error: unknown) {
+        this.logger.error(
+            `Call attempt to ${method.name} failed: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+
+    protected handleCTraderCallError(
+        error: ProtoOAErrorRes,
+        method: Function,
+        rethrowError: cTraderXError,
+    ): cTraderXError {
+        const message = cTraderXError.getMessageError(error);
+        this.logCallAttemptFailure(method, message);
+        return rethrowError;
+    }
+}

package/src/classes/managers/models/credentials.model.ts

@@ -0,0 +1,15 @@
+import { IConfiguration } from '../../models/client-configuration.model';
+
+export interface ICredentials extends Pick<
+    IConfiguration,
+    | 'clientId'
+    | 'clientSecret'
+    | 'ctidTraderAccountId'
+    | 'accessToken'
+    | 'accessToken'
+> {
+    clientId: string;
+    accessToken: string;
+    clientSecret: string;
+    ctidTraderAccountId: number;
+}

package/src/classes/managers/symbols/errors/get-symbols-details.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class GetSymbolsDetailsError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Get symbols details error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/symbols/errors/get-symbols-list.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class GetSymbolsListError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Get symbols list error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/symbols/errors/get-trend-bars.error.ts

@@ -0,0 +1,7 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class GetTrendBarsError extends cTraderXError {
+    constructor(readonly error: unknown) {
+        super(`Get trend bars error: ${cTraderXError.getMessageError(error)}`);
+    }
+}

package/src/classes/managers/symbols/errors/subscribe-live-trend-bars.error.ts

@@ -0,0 +1,17 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class SubscribeLiveTrendBarsError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Subscribe live trend bars error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}
+
+export class SubscribeLiveTrendBarsInternalError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `[INTERNAL] Subscribe live trend bars error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/symbols/errors/subscribe-spot-events.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class SubscribeSpotEventsError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Subscribe spot events error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}

package/src/classes/managers/symbols/errors/unsubscribe-live-trend-bars.error.ts

@@ -0,0 +1,9 @@
+import { cTraderXError } from '../../../models/ctrader-x-error.model';
+
+export class UnsubscribeLiveTrendBarsError extends cTraderXError {
+    constructor(error: unknown) {
+        super(
+            `Unsubscribe live trend bars error: ${cTraderXError.getMessageError(error)}`,
+        );
+    }
+}