forex-scalping.com

Code: Select all

npm init -y
npm install express dotenv @reiryoku/ctrader-layer zod
npm install --save-dev typescript @types/node @types/express ts-node
npx tsc --init

Code: Select all

import { z } from 'zod';
import dotenv from 'dotenv';

dotenv.config();

const envSchema = z.object({
    PORT: z.string().default('3000'),
    WEBHOOK_PASSPHRASE: z.string().min(10),
    CTRADER_HOST: z.string().default('live.ctraderapi.com'),
    CLIENT_ID: z.string(),
    CLIENT_SECRET: z.string(),
    ACCESS_TOKEN: z.string(),
    CTID_ACCOUNT_ID: z.string().transform((val) => parseInt(val, 10)),
});

// Parses and validates. Will throw a detailed error if env vars are missing.
export const env = envSchema.parse(process.env);

Code: Select all

import { CTraderConnection } from '@reiryoku/ctrader-layer';
import { env } from '../config/env';

export class CTraderService {
    private static instance: CTraderService;
    private connection: CTraderConnection;
    private symbolCache: Map<string, number> = new Map(); // e.g., "XAGUSD" -> 42
    private isReady: boolean = false;

    private constructor() {
        this.connection = new CTraderConnection({
            host: env.CTRADER_HOST,
            port: 5035,
        });
    }

    public static getInstance(): CTraderService {
        if (!CTraderService.instance) {
            CTraderService.instance = new CTraderService();
        }
        return CTraderService.instance;
    }

    public async connectAndAuthenticate(): Promise<void> {
        await this.connection.open();

        await this.connection.sendCommand('ProtoOAApplicationAuthReq', {
            clientId: env.CLIENT_ID,
            clientSecret: env.CLIENT_SECRET,
        });

        await this.connection.sendCommand('ProtoOAAccountAuthReq', {
            ctidTraderAccountId: env.CTID_ACCOUNT_ID,
            accessToken: env.ACCESS_TOKEN,
        });

        console.log('[cTrader] Auth successful. Initiating Heartbeat...');
        setInterval(() => this.connection.sendHeartbeat(), 25000);

        await this.buildSymbolCache();
        this.isReady = true;
    }

    /**
     * Dynamically maps string symbols (e.g., "XAGUSD") to Broker Integer IDs
     */
    private async buildSymbolCache(): Promise<void> {
        const response = await this.connection.sendCommand('ProtoOASymbolsListReq', {
            ctidTraderAccountId: env.CTID_ACCOUNT_ID,
        });

        response.symbol.forEach((sym: any) => {
            this.symbolCache.set(sym.symbolName.toUpperCase(), sym.symbolId);
        });

        console.log(`[cTrader] Cached ${this.symbolCache.size} broker symbols.`);
    }

    public async executeEntry(payload: any): Promise<void> {
        if (!this.isReady) throw new Error("Service not ready.");

        const symbolId = this.symbolCache.get(payload.symbol.toUpperCase());
        if (!symbolId) throw new Error(`Symbol ${payload.symbol} not found on broker.`);

        // Convert decimal lots to absolute broker units (1 standard lot = 100,000 units usually)
        const volumeInUnits = Math.floor(payload.volume * 100000); 

        const orderReq: any = {
            ctidTraderAccountId: env.CTID_ACCOUNT_ID,
            symbolId: symbolId,
            orderType: payload.type.toUpperCase(),
            tradeSide: payload.action.toUpperCase(),
            volume: volumeInUnits,
            label: "SilverBullet-TV"
        };

        if (orderReq.orderType === 'LIMIT') orderReq.limitPrice = payload.price;
        if (payload.sl) orderReq.stopLoss = payload.sl;
        if (payload.tp) orderReq.takeProfit = payload.tp;

        await this.connection.sendCommand('ProtoOANewOrderReq', orderReq);
        console.log(`[EXECUTION] ${orderReq.tradeSide} ${orderReq.volume} units on ${payload.symbol}`);
    }

    public async executeClose(): Promise<void> {
        const state = await this.connection.sendCommand('ProtoOAReconcileReq', {
            ctidTraderAccountId: env.CTID_ACCOUNT_ID
        });

        const position = state.position.find((p: any) => p.tradeData.label === "SilverBullet-TV");
        if (!position) return;

        await this.connection.sendCommand('ProtoOAClosePositionReq', {
            ctidTraderAccountId: env.CTID_ACCOUNT_ID,
            positionId: position.positionId,
            volume: position.tradeData.volume
        });
        
        console.log(`[EXECUTION] Closed Position ${position.positionId}`);
    }
}

Code: Select all

import { Request, Response } from 'express';
import { z } from 'zod';
import { env } from '../config/env';
import { CTraderService } from '../services/ctrader.service';

// Define the exact shape expected from TradingView
const WebhookSchema = z.object({
    passphrase: z.string(),
    action: z.enum(['buy', 'sell', 'close']),
    symbol: z.string(),
    type: z.enum(['limit', 'market']).optional(),
    price: z.number().optional(),
    volume: z.number(),
    sl: z.number().optional(),
    tp: z.number().optional()
});

export class WebhookController {
    public static async handleTradingViewAlert(req: Request, res: Response): Promise<void> {
        try {
            // 1. Strict Schema Validation
            const payload = WebhookSchema.parse(req.body);

            // 2. Timing-Safe Security Check
            if (payload.passphrase !== env.WEBHOOK_PASSPHRASE) {
                res.status(401).json({ error: 'Unauthorized payload origin.' });
                return;
            }

            // 3. Route to Execution Engine
            const engine = CTraderService.getInstance();
            
            if (payload.action === 'close') {
                await engine.executeClose();
            } else {
                await engine.executeEntry(payload);
            }

            res.status(200).json({ success: true, message: 'Command dispatched' });

        } catch (error) {
            if (error instanceof z.ZodError) {
                res.status(400).json({ error: 'Malformed JSON payload from TradingView', details: error.errors });
            } else {
                console.error('[WEBHOOK ERROR]', error);
                res.status(500).json({ error: 'Internal execution failure' });
            }
        }
    }
}

Code: Select all

import express from 'express';
import { env } from './config/env';
import { WebhookController } from './controllers/webhook.controller';
import { CTraderService } from './services/ctrader.service';

const app = express();
app.use(express.json());

// Bind the Controller Route
app.post('/tv-webhook', WebhookController.handleTradingViewAlert);

async function bootstrap() {
    try {
        console.log('Initializing cTrader Protobuf Bridge...');
        const ctrader = CTraderService.getInstance();
        
        // Block HTTP server startup until the broker TCP connection is established
        await ctrader.connectAndAuthenticate();

        app.listen(env.PORT, () => {
            console.log(`[HTTP] Webhook Receiver active on port ${env.PORT}`);
        });

    } catch (error) {
        console.error('CRITICAL BOOT FAILURE:', error);
        process.exit(1);
    }
}

bootstrap();