FreelanceSections

⏱️ Urgent project – looking for an experienced developer to finalize MT4 bot (deadline: Tuesday)

MQL5 Experts Forex Trading robot/indicator debugging Uploading data to a website

Spécifications

"""
Fast Multi-Pair RSI Trading Bot
Supports:
- BTCUSDT
- XAUUSD
- GBPUSD

Opens fast buy or sell trades based on RSI signals
Closes trades after 5, 10, or 15 minutes
"""

import asyncio
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional
import pandas as pd
import numpy as np

# ===== RSI calculation ===== #
def compute_rsi(close: pd.Series, period: int = 14) -> pd.Series:
    delta = close.diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)
    avg_gain = gain.ewm(alpha=1 / period, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1 / period, adjust=False).mean()
    rs = avg_gain / avg_loss
    return 100 - (100 / (1 + rs))

# ===== Position structure ===== #
@dataclass
class Position:
    id: str
    symbol: str
    side: str
    entry_price: float
    size: float
    opened_at: float
    duration_min: int

# ===== Config ===== #
@dataclass
class BotConfig:
    symbols: List[str] = field(default_factory=lambda: ["BTCUSDT", "XAUUSD", "GBPUSD"])
    rsi_period: int = 14
    rsi_oversold: int = 30
    rsi_overbought: int = 70
    durations_min: List[int] = field(default_factory=lambda: [5, 10, 15])
    account_equity: float = 2000.0
    risk_pct: float = 0.5
    lot_size: Optional[float] = None
    paper: bool = True

# ===== Trading Bot ===== #
class MultiPairRSIBot:
    def __init__(self, cfg: BotConfig):
        self.cfg = cfg
        self.data: Dict[str, pd.DataFrame] = {sym: pd.DataFrame() for sym in cfg.symbols}
        self.positions: Dict[str, Dict[str, Position]] = {sym: {} for sym in cfg.symbols}
        self._id = 0

    # ========== Fake 1-minute feed for PAPER mode ========== #
    def get_fake_ohlcv(self, symbol):
        now = int(time.time()) * 1000
        df = self.data[symbol]

        last_close = df["close"].iloc[-1] if not df.empty else 1000 + np.random.rand() * 10
        change = np.random.normal(0, 0.0008)
        close = last_close * (1 + change)
        high = max(last_close, close)
        low = min(last_close, close)

        return (now, last_close, high, low, close, 0)

    # ========== Append new candle ========== #
    def append_candle(self, symbol, ohlc):
        ts, o, h, l, c, v = ohlc
        row = {"timestamp": pd.to_datetime(ts, unit="ms"),
               "open": o, "high": h, "low": l, "close": c, "volume": v}
        self.data[symbol] = pd.concat([self.data[symbol], pd.DataFrame([row])], ignore_index=True)
        if len(self.data[symbol]) > 2000:
            self.data[symbol] = self.data[symbol].iloc[-2000:]

    # ========== Timeframe aggregation ========== #
    def to_tf(self, symbol, minutes):
        df = self.data[symbol]
        if df.empty:
            return pd.DataFrame()
        df["bucket"] = df["timestamp"].dt.floor(f"{minutes}T")
        out = df.groupby("bucket").agg({
            "open": "first",
            "high": "max",
            "low": "min",
            "close": "last",
            "volume": "sum"
        }).reset_index().rename(columns={"bucket": "timestamp"})
        return out

    # ========== Position sizing ========== #
    def get_size(self, price):
        if self.cfg.lot_size:
            return self.cfg.lot_size
        risk_amount = self.cfg.account_equity * (self.cfg.risk_pct / 100)
        return round(risk_amount / price, 4)

    # ========== Check RSI signals and enter trades ========== #
    async def process_signals(self, symbol):
        for dur in self.cfg.durations_min:
            df = self.to_tf(symbol, dur)
            if len(df) < self.cfg.rsi_period + 2:
                continue

            df["rsi"] = compute_rsi(df["close"], self.cfg.rsi_period)

            prev = df["rsi"].iloc[-2]
            last = df["rsi"].iloc[-1]
            price = df["close"].iloc[-1]

            # BUY: RSI cross up
            if prev <= self.cfg.rsi_oversold and last > prev:
                size = self.get_size(price)
                await self.open_position(symbol, "buy", price, size, dur)

            # SELL: RSI cross down
            if prev >= self.cfg.rsi_overbought and last < prev:
                size = self.get_size(price)
                await self.open_position(symbol, "sell", price, size, dur)

    # ========== Open position ========== #
    async def open_position(self, symbol, side, price, size, duration):
        self._id += 1
        pid = f"{symbol}_{self._id}"
        print(f"[{symbol}] OPEN {side.upper()} @ {price:.2f} | {duration}m | size {size}")

        pos = Position(
            id=pid,
            symbol=symbol,
            side=side,
            entry_price=price,
            size=size,
            opened_at=time.time(),
            duration_min=duration
        )
        self.positions[symbol][pid] = pos

    # ========== Close expired trades ========== #
    async def close_expired(self, symbol):
        now = time.time()
        to_close = []

        for pid, pos in self.positions[symbol].items():
            if (now - pos.opened_at) / 60 >= pos.duration_min:
                to_close.append(pid)

        for pid in to_close:
            await self.close_position(symbol, pid)

    # ========== Close position ========== #
    async def close_position(self, symbol, pid):
        pos = self.positions[symbol][pid]
        last_price = self.data[symbol]["close"].iloc[-1]
        pnl = (last_price - pos.entry_price) * pos.size if pos.side == "buy" else (pos.entry_price - last_price) * pos.size

        print(f"[{symbol}] CLOSE {pos.side.upper()} @ {last_price:.2f} | PnL = {pnl:.3f}")
        self.cfg.account_equity += pnl
        del self.positions[symbol][pid]

    # ========== Main loop ========== #
    async def start(self):
        print("Starting multi-pair RSI bot...")
        print("Symbols:", self.cfg.symbols)

        while True:
            try:
                for symbol in self.cfg.symbols:

                    # new candle
                    ohlcv = self.get_fake_ohlcv(symbol)
                    self.append_candle(symbol, ohlcv)

                    # signal scan
                    await self.process_signals(symbol)

                    # manage trades
                    await self.close_expired(symbol)

            except Exception as e:
                print("Error:", e)

            await asyncio.sleep(1)

# ========== Launch Example ========== #
async def main():
    cfg = BotConfig(
        symbols=["BTCUSDT", "XAUUSD", "GBPUSD"],
        account_equity=3000.0,
        paper=True,
        lot_size=None
    )
    bot = MultiPairRSIBot(cfg)

    task = asyncio.create_task(bot.start())
    await asyncio.sleep(60 * 5) # run 5 minutes demo
    task.cancel()

if __name__ == "__main__":
    asyncio.run(main())

Répondu

1
Développeur 1
Évaluation
(635)
Projets
1005
47%
Arbitrage
33
36% / 36%
En retard
99
10%
Travail
Publié : 6 codes
2
Développeur 2
Évaluation
(21)
Projets
27
7%
Arbitrage
9
33% / 33%
En retard
1
4%
Travail
3
Développeur 3
Évaluation
(48)
Projets
58
34%
Arbitrage
15
27% / 60%
En retard
1
2%
Travail
4
Développeur 4
Évaluation
(7)
Projets
6
0%
Arbitrage
4
25% / 75%
En retard
2
33%
Gratuit
5
Développeur 5
Évaluation
(8)
Projets
11
0%
Arbitrage
8
25% / 63%
En retard
2
18%
Travail
6
Développeur 6
Évaluation
(16)
Projets
35
23%
Arbitrage
4
0% / 50%
En retard
2
6%
Travail
7
Développeur 7
Évaluation
(1)
Projets
2
0%
Arbitrage
2
0% / 50%
En retard
0
Gratuit
8
Développeur 8
Évaluation
(2)
Projets
2
0%
Arbitrage
0
En retard
0
Gratuit
9
Développeur 9
Évaluation
(17)
Projets
21
14%
Arbitrage
8
38% / 38%
En retard
3
14%
Chargé
10
Développeur 10
Évaluation
(611)
Projets
711
33%
Arbitrage
45
49% / 42%
En retard
14
2%
Travail
11
Développeur 11
Évaluation
(22)
Projets
29
34%
Arbitrage
4
50% / 25%
En retard
5
17%
Travail
12
Développeur 12
Évaluation
(4)
Projets
3
33%
Arbitrage
2
0% / 100%
En retard
0
Gratuit
13
Développeur 13
Évaluation
(2672)
Projets
3408
68%
Arbitrage
77
48% / 14%
En retard
342
10%
Gratuit
Publié : 1 code
14
Développeur 14
Évaluation
(2)
Projets
3
0%
Arbitrage
0
En retard
0
Gratuit
15
Développeur 15
Évaluation
(1)
Projets
0
0%
Arbitrage
1
0% / 100%
En retard
0
Gratuit
16
Développeur 16
Évaluation
(1)
Projets
1
100%
Arbitrage
0
En retard
0
Gratuit
17
Développeur 17
Évaluation
(258)
Projets
267
30%
Arbitrage
0
En retard
3
1%
Travail
Publié : 2 codes
18
Développeur 18
Évaluation
(29)
Projets
33
27%
Arbitrage
20
10% / 50%
En retard
11
33%
Gratuit
19
Développeur 19
Évaluation
(10)
Projets
12
0%
Arbitrage
3
33% / 33%
En retard
1
8%
Gratuit
20
Développeur 20
Évaluation
(298)
Projets
478
40%
Arbitrage
105
40% / 24%
En retard
82
17%
Chargé
Publié : 2 codes
21
Développeur 21
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
22
Développeur 22
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
23
Développeur 23
Évaluation
Projets
0
0%
Arbitrage
0
En retard
0
Gratuit
Commandes similaires
I need a developer to help me create a standard, fully automated forex marketing package. 30+ USD
1. The general process is: Automated online forex marketing to find potential clients -> Answering potential clients' questions -> Converting them into actual clients -> Opening accounts, depositing funds, and copying trades. 2. Developers could implement an AI Digital Twin/Shadow Agent to answer customer questions, eliminating the need for me to answer customer inquiries. 3. I have a CTA website and I'm manually
Iconic Boy 300 - 400 USD
Am looking for a bot to trade .so that I can be able to trade and become very successful and make some profit so that I cannot sleep on a empty stomach
8 cap prop firm passing 30 - 3000 USD
I am looking for an experienced MQL4/MQL5 HFT developer to build or optimize a High-Frequency Trading (HFT) Expert Advisor that can successfully pass proprietary trading firm challenges and perform consistently under live trading conditions with brokers such as 8cap or BlackBull Markets . The developer should have proven experience with HFT execution, ultra-low-latency trading, broker execution, slippage, spreads
MT4/MT5 HFT EA Live Trading 40 - 10000 USD
I have a High-Frequency Trading (HFT) Expert Advisor for both MT4 and MT5 designed primarily for US30 (Dow Jones Index) . The EA performs consistently and profitably on demo accounts, but when I run it on an IC Markets Raw or Standard live account, it starts generating losses under what appear to be the same trading conditions. At this time, I cannot provide the source code (.mq4/.mq5). I can only provide the
EA Crafter 500+ USD
Act as a professional Quantitative Developer and Risk Manager. I want to build a systematic trading strategy rulebook that prioritizes capital preservation and statistical edge over raw performance. Please generate a structured trading strategy using the following framework: 1. ASSET CLASS & TIMEFRAME: - Asset: [e.g., Apple (AAPL), Bitcoin (BTC), or EUR/USD] - Timeframe: [e.g., 5-minute, 1-hour, Daily] 2. CORE

Informations sur le projet

Budget
50+ USD