[PRO TIP] The Zero-Leverage Silver Buffer: How to Fund Your Forex Scalping Series Risk-Free

[PTScalper]

Hey everyone, welcome back to another strategy breakdown here on forex-scalping.com.

Watching the price action recently, I’ve noticed a lot of newer traders struggling with early drawdowns in their initial forex series. When you're just starting, taking a hit on your core capital immediately messes with your psychology and leads to forced, emotional trades. After 18 years in the markets and pushing thousands of lots in volume, I want to share a structural approach to build a risk-free buffer before you dive into heavy forex pairs.

The secret? XAGUSD (Silver).

Here is the exact framework you should try at the start of your next trading series:

Phase 1: The Zero-Leverage Silver Long

Before you execute your primary forex algorithms or manual scalps, open a Long position on XAGUSD. But here is the absolutely critical rule: You must trade this with NO leverage (1:1).

Why Silver? XAGUSD is incredibly volatile. Even without the multiplier of leverage, its daily and weekly price swings are wide enough to generate meaningful absolute dollar profits.

Why No Leverage? By stripping away the margin multiplier, your liquidation risk essentially drops to zero. Silver is a physical, high-demand asset—it is never going to zero. You are simply parking capital and letting the natural volatility do the work. It becomes a matter of when it hits your take-profit, not if you get margin-called.

Phase 2: The "House Money" Transfer

Once your unleveraged XAGUSD trade swings into profit and hits your target, close it out. You now have realized, stress-free profit.

Take only that specific profit segment and allocate it as the risk capital (margin) for your main forex series.

If your subsequent forex scalping series hits a stop-loss, you haven't lost a single cent of your initial equity. You only lost the silver buffer.

The Psychological Edge

The hardest part of high-volume scalping isn't the technical analysis or the server latency; it's the mental game. Trading your forex series using profits generated from an unleveraged, low-stress silver trade removes the emotion. You execute your setups with extreme clarity because you are mathematically playing with the market's money.

Give this sequence a try to start your week. I might break down a live execution of this exact setup in an upcoming video on the Forex, Stocks & Me channel so you can see the volume scaling in real-time.

Drop your thoughts or questions below. How are you guys currently building your risk buffers?

[PTScalper]

One crucial detail I should emphasize: your broker choice can make or break this entire strategy.

Whether you're holding an unleveraged position on XAGUSD or executing high-frequency scalping on major forex pairs, your margins and edge will quickly get eaten alive if you're dealing with wide spreads, hidden markups, or slippage during volatility spikes.

For high-volume trading and scalping, you need:

True Raw ECN Spreads: Spreads starting from 0.0 pips so your entry/exit costs stay minimal.

Ultra-Low Latency Execution: Fast fill speeds (NY4/LD4 server connectivity) to avoid requotes when silver or forex pairs make sharp moves.

Deep Liquidity & Fair Commissions: Transparent fee structures that don't penalize active trading series.

If you don't have a dedicated raw spread account yet, I personally execute my trading on IC Markets. They offer some of the tightest spreads and best server infrastructure available for scalpers and algorithmic traders:

Open a Raw Spread Account on IC Markets Here

(Make sure to select the Raw Spread / cTrader or MT5 account type to get true 0.0 pip spreads on majors).

[PTScalper]

Hi traders/scalpers.

I prepared for you EA, which implements this strategy:

This is a rock-solid structural approach to eliminating early drawdown anxiety. Trading purely on the market's money fundamentally shifts the psychological dynamic of high-volume scalping.

Here is the MT4 (MQL4) framework built specifically for this two-phase sequence. This Expert Advisor handles the 1:1 unleveraged XAGUSD sizing dynamically, secures the target profit, and then transitions into a protected Phase 2 for your core forex pairs.

Code: Select all

//+------------------------------------------------------------------+
//|                                                SilverBuffer.mq4  |
//|                             Generated for forex-scalping.com     |
//+------------------------------------------------------------------+
#property copyright "Forex, Stocks & Me"
#property link      "https://forex-scalping.com"
#property version   "1.00"
#property strict

//--- Input Parameters
input string   SilverSymbol      = "XAGUSD";  // Silver Symbol
input double   SilverTargetUSD   = 50.0;      // Phase 1: Buffer Target (USD)
input string   ForexSymbol       = "EURUSD";  // Phase 2: Forex Symbol
input double   ForexLotSize      = 1.0;       // Phase 2: Scalping Lot Size
input int      ForexMagic        = 12345;     // Phase 2: Magic Number
input int      SilverMagic       = 54321;     // Phase 1: Magic Number

//--- State Variables
int    TradingPhase = 1; 
double RiskBufferUSD = 0.0;
double Phase2StartEquity = 0.0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   Print("Initializing Zero-Leverage Buffer Strategy...");
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(TradingPhase == 1)
     {
      ExecutePhase1();
     }
   else if(TradingPhase == 2)
     {
      ExecutePhase2();
     }
  }

//+------------------------------------------------------------------+
//| Phase 1: The Zero-Leverage Silver Long                           |
//+------------------------------------------------------------------+
void ExecutePhase1()
  {
   int totalSilver = 0;
   double currentProfit = 0.0;
   int silverTicket = -1;
   
   // Scan open Silver positions
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == SilverSymbol && OrderMagicNumber() == SilverMagic)
           {
            totalSilver++;
            currentProfit = OrderProfit() + OrderSwap() + OrderCommission();
            silverTicket = OrderTicket();
           }
        }
     }
     
   // Entry: Open unleveraged XAGUSD Long
   if(totalSilver == 0)
     {
      double lotSize = CalculateUnleveragedSilverLots();
      if(lotSize > 0)
        {
         double ask = MarketInfo(SilverSymbol, MODE_ASK);
         int ticket = OrderSend(SilverSymbol, OP_BUY, lotSize, ask, 3, 0, 0, "Phase 1: Buffer Build", SilverMagic, 0, clrBlue);
         if(ticket > 0) Print("Phase 1 Initiated: Unleverage Silver Long opened. Lots: ", lotSize);
        }
     }
   // Exit: Target reached, lock buffer and transition to Phase 2
   else if(totalSilver > 0 && currentProfit >= SilverTargetUSD)
     {
      if(OrderSelect(silverTicket, SELECT_BY_TICKET))
        {
         double bid = MarketInfo(SilverSymbol, MODE_BID);
         if(OrderClose(OrderTicket(), OrderLots(), bid, 3, clrRed))
           {
            RiskBufferUSD = currentProfit;
            Phase2StartEquity = AccountEquity();
            TradingPhase = 2; 
            Print("Phase 1 Complete. Buffer Locked: $", RiskBufferUSD, ". Transitioning to Phase 2.");
           }
        }
     }
  }

//+------------------------------------------------------------------+
//| Phase 2: The "House Money" Transfer                              |
//+------------------------------------------------------------------+
void ExecutePhase2()
  {
   // Risk Check: Flush all trades if buffer is depleted
   if(AccountEquity() <= (Phase2StartEquity - RiskBufferUSD))
     {
      CloseAllForexTrades();
      Print("Risk buffer depleted. Reverting to Phase 1.");
      TradingPhase = 1;
      RiskBufferUSD = 0.0;
      return;
     }
     
   // --- CORE SCALPING ALGORITHM GOES HERE ---
   // This is where your high-volume real-time price action execution runs.
   
   int totalForex = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == ForexSymbol && OrderMagicNumber() == ForexMagic)
            totalForex++;
        }
     }
     
   // Placeholder execution block
   if(totalForex == 0)
     {
      // Insert your custom technical indicators or order flow logic here.
      /*
      double ask = MarketInfo(ForexSymbol, MODE_ASK);
      OrderSend(ForexSymbol, OP_BUY, ForexLotSize, ask, 3, 0, ask + 10 * Point, "Phase 2 Core Scalp", ForexMagic, 0, clrGreen);
      */
     }
  }

//+------------------------------------------------------------------+
//| Calculate 1:1 Unleveraged Lot Size                               |
//+------------------------------------------------------------------+
double CalculateUnleveragedSilverLots()
  {
   double contractSize = MarketInfo(SilverSymbol, MODE_LOTSIZE);
   double askPrice = MarketInfo(SilverSymbol, MODE_ASK);
   
   if(contractSize == 0 || askPrice == 0) return 0;
   
   // 1:1 Leverage constraint: Notional Exposure = Total Account Balance
   double positionValue = AccountBalance();
   double rawLots = positionValue / (contractSize * askPrice);
   
   double minLot = MarketInfo(SilverSymbol, MODE_LOTSTEP); // Fallback to step if minlot is 0
   if(MarketInfo(SilverSymbol, MODE_MINLOT) > 0) minLot = MarketInfo(SilverSymbol, MODE_MINLOT);
   
   double maxLot = MarketInfo(SilverSymbol, MODE_MAXLOT);
   double lotStep = MarketInfo(SilverSymbol, MODE_LOTSTEP);
   
   // Normalize sizing down to the broker's required lot increment
   double calcLots = MathFloor(rawLots / lotStep) * lotStep;
   
   if(calcLots < minLot) calcLots = minLot;
   if(calcLots > maxLot) calcLots = maxLot;
   
   return calcLots;
  }

//+------------------------------------------------------------------+
//| Emergency/Buffer Stop Logic                                      |
//+------------------------------------------------------------------+
void CloseAllForexTrades()
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == ForexSymbol && OrderMagicNumber() == ForexMagic)
           {
            double closePrice = (OrderType() == OP_BUY) ? MarketInfo(ForexSymbol, MODE_BID) : MarketInfo(ForexSymbol, MODE_ASK);
            OrderClose(OrderTicket(), OrderLots(), closePrice, 3, clrRed);
           }
        }
     }
  }

[PTScalper]

Core Logic BreakdownDynamic 1:1 Unleveraged Sizing:

The CalculateUnleveragedSilverLots() function ensures your physical exposure never exceeds your account balance, minimizing liquidation risk. It dynamically reads your broker's XAGUSD contract size (which is typically 5,000 ounces per standard lot) and calculates the exact position size where the notional value equals your balance. It then normalizes the final number down to the broker's required lot increment.

Phase Transition: Once your SilverTargetUSD is hit, it banks the profit, snapshots the new equity high, and locks the realized gains into RiskBufferUSD.Capital Protection (House Money): During Phase 2, the EA constantly monitors your AccountEquity(). The millisecond your equity dips below Phase2StartEquity - RiskBufferUSD, it flushes all open forex positions and reverts immediately back to Phase 1.

[PTScalper]

Plus i prepared MT5 version as well.

Migrating this sequence to MetaTrader 5 is a smart move, especially when you are running trade latency tests. MT5's asynchronous order routing and modern standard library drastically reduce execution drag during high-volume scalping phases compared to MT4's older, synchronous thread model.

Here is the exact strategy refactored for MQL5. The biggest structural difference is that MT5 strictly separates pending orders from open positions, and we can utilize the built-in CTrade class to handle the execution heavy lifting.

Code: Select all

//+------------------------------------------------------------------+
//|                                                SilverBuffer.mq5  |
//|                             Generated for forex-scalping.com     |
//+------------------------------------------------------------------+
#property copyright "Forex, Stocks & Me"
#property link      "https://forex-scalping.com"
#property version   "1.00"

#include <Trade\Trade.mqh>

//--- Input Parameters
input string   SilverSymbol      = "XAGUSD";  // Phase 1: Silver Symbol
input double   SilverTargetUSD   = 50.0;      // Phase 1: Buffer Target (USD)
input string   ForexSymbol       = "EURUSD";  // Phase 2: Forex Symbol
input double   ForexLotSize      = 1.0;       // Phase 2: Scalping Lot Size
input ulong    ForexMagic        = 12345;     // Phase 2: Magic Number
input ulong    SilverMagic       = 54321;     // Phase 1: Magic Number

//--- State Variables
int    TradingPhase = 1; 
double RiskBufferUSD = 0.0;
double Phase2StartEquity = 0.0;

//--- Trade Objects
CTrade tradePhase1;
CTrade tradePhase2;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Assign magic numbers to our trade execution objects
   tradePhase1.SetExpertMagicNumber(SilverMagic);
   tradePhase2.SetExpertMagicNumber(ForexMagic);
   Print("MT5 Zero-Leverage Buffer Strategy Initialized.");
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(TradingPhase == 1)
     {
      ExecutePhase1();
     }
   else if(TradingPhase == 2)
     {
      ExecutePhase2();
     }
  }

//+------------------------------------------------------------------+
//| Phase 1: The Zero-Leverage Silver Long                           |
//+------------------------------------------------------------------+
void ExecutePhase1()
  {
   int totalSilver = 0;
   double currentProfit = 0.0;
   ulong silverTicket = 0;
   
   // MT5: Loop through open POSITIONS, not pending orders
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetString(POSITION_SYMBOL) == SilverSymbol && PositionGetInteger(POSITION_MAGIC) == SilverMagic)
        {
         totalSilver++;
         // Calculate net profit (excluding deal-based commission, which MT5 handles separately)
         currentProfit = PositionGetDouble(POSITION_PROFIT) + PositionGetDouble(POSITION_SWAP);
         silverTicket = ticket;
        }
     }
     
   // Entry: Open unleveraged XAGUSD Long
   if(totalSilver == 0)
     {
      double lotSize = CalculateUnleveragedSilverLots();
      if(lotSize > 0)
        {
         double ask = SymbolInfoDouble(SilverSymbol, SYMBOL_ASK);
         if(tradePhase1.Buy(lotSize, SilverSymbol, ask, 0, 0, "Phase 1: Buffer Build"))
           {
            Print("Phase 1 Initiated: Unleverage Silver Long opened. Lots: ", lotSize);
           }
        }
     }
   // Exit: Target reached, lock buffer and transition to Phase 2
   else if(totalSilver > 0 && currentProfit >= SilverTargetUSD)
     {
      if(tradePhase1.PositionClose(silverTicket))
        {
         RiskBufferUSD = currentProfit;
         Phase2StartEquity = AccountInfoDouble(ACCOUNT_EQUITY);
         TradingPhase = 2; 
         Print("Phase 1 Complete. Buffer Locked: $", RiskBufferUSD, ". Transitioning to Phase 2.");
        }
     }
  }

//+------------------------------------------------------------------+
//| Phase 2: The "House Money" Transfer                              |
//+------------------------------------------------------------------+
void ExecutePhase2()
  {
   // Risk Check: Flush all trades if buffer is depleted
   if(AccountInfoDouble(ACCOUNT_EQUITY) <= (Phase2StartEquity - RiskBufferUSD))
     {
      CloseAllForexTrades();
      Print("Risk buffer depleted. Reverting to Phase 1.");
      TradingPhase = 1;
      RiskBufferUSD = 0.0;
      return;
     }
     
   // --- CORE SCALPING ALGORITHM GOES HERE ---
   
   int totalForex = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetString(POSITION_SYMBOL) == ForexSymbol && PositionGetInteger(POSITION_MAGIC) == ForexMagic)
         totalForex++;
     }
     
   // Placeholder execution block
   if(totalForex == 0)
     {
      // Insert your custom order flow logic here.
      // Example: tradePhase2.Buy(ForexLotSize, ForexSymbol, ask, sl, tp, "Phase 2 Core Scalp");
     }
  }

//+------------------------------------------------------------------+
//| Calculate 1:1 Unleveraged Lot Size                               |
//+------------------------------------------------------------------+
double CalculateUnleveragedSilverLots()
  {
   double contractSize = SymbolInfoDouble(SilverSymbol, SYMBOL_TRADE_CONTRACT_SIZE);
   double askPrice = SymbolInfoDouble(SilverSymbol, SYMBOL_ASK);
   
   if(contractSize == 0 || askPrice == 0) return 0;
   
   double positionValue = AccountInfoDouble(ACCOUNT_BALANCE);
   double rawLots = positionValue / (contractSize * askPrice);
   
   double minLot = SymbolInfoDouble(SilverSymbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(SilverSymbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(SilverSymbol, SYMBOL_VOLUME_STEP);
   
   if(lotStep == 0) return 0; // Prevent divide-by-zero
   
   // Normalize sizing down to the broker's required lot increment
   double calcLots = MathFloor(rawLots / lotStep) * lotStep;
   
   if(calcLots < minLot) calcLots = minLot;
   if(calcLots > maxLot) calcLots = maxLot;
   
   return calcLots;
  }

//+------------------------------------------------------------------+
//| Emergency/Buffer Stop Logic                                      |
//+------------------------------------------------------------------+
void CloseAllForexTrades()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetString(POSITION_SYMBOL) == ForexSymbol && PositionGetInteger(POSITION_MAGIC) == ForexMagic)
        {
         tradePhase2.PositionClose(ticket);
        }
     }
  }

[PTScalper]

Key MQL5 Upgrades:

The CTrade Class: Replaces all manual OrderSend and OrderClose functions. It automatically handles slippage, retries, and formatting. We instantiate two separate CTrade objects (tradePhase1 and tradePhase2) so we don't have to constantly swap out the Magic Numbers on a single object.

Position Iteration: The ExecutePhase1() and ExecutePhase2() loops now correctly iterate backward through PositionsTotal() using PositionGetTicket(), completely bypassing pending limit/stop orders.

Environmental Constants: Functions like MarketInfo() have been updated to their native MT5 equivalents: SymbolInfoDouble() and AccountInfoDouble(), which are significantly faster to call on every tick.

[PTScalper]

Porting this framework to cTrader (C#) allows you to take advantage of its modern API architecture. The transition from MQL to cTrader Automate is generally much cleaner because C# is fully object-oriented, and cTrader natively handles position filtering without the need for manual loops.

A major architectural difference here is the use of Labels instead of Magic Numbers, which is the idiomatic way cTrader groups and manages trades. Additionally, cTrader simplifies the 1:1 volume calculation by natively handling units instead of abstract contract multipliers.

Here is the complete C# cBot for your two-phase strategy:

Code: Select all

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class SilverBufferStrategy : Robot
    {
        // --- Input Parameters ---
        [Parameter("Silver Symbol", DefaultValue = "XAGUSD", Group = "Phase 1: Buffer Build")]
        public string SilverSymbolName { get; set; }

        [Parameter("Buffer Target (USD)", DefaultValue = 50.0, Group = "Phase 1: Buffer Build")]
        public double SilverTargetUSD { get; set; }

        [Parameter("Phase 1 Label", DefaultValue = "Phase1_Silver", Group = "Phase 1: Buffer Build")]
        public string SilverLabel { get; set; }

        [Parameter("Forex Symbol", DefaultValue = "EURUSD", Group = "Phase 2: Core Scalping")]
        public string ForexSymbolName { get; set; }

        [Parameter("Forex Volume (Lots)", DefaultValue = 1.0, Group = "Phase 2: Core Scalping")]
        public double ForexLotSize { get; set; }

        [Parameter("Phase 2 Label", DefaultValue = "Phase2_Forex", Group = "Phase 2: Core Scalping")]
        public string ForexLabel { get; set; }

        // --- State Variables ---
        private int _tradingPhase = 1;
        private double _riskBufferUSD = 0.0;
        private double _phase2StartEquity = 0.0;
        
        private Symbol _silverSymbol;
        private Symbol _forexSymbol;

        protected override void OnStart()
        {
            // Initialize multi-symbol objects
            _silverSymbol = Symbols.GetSymbol(SilverSymbolName);
            _forexSymbol = Symbols.GetSymbol(ForexSymbolName);

            if (_silverSymbol == null || _forexSymbol == null)
            {
                Print("Initialization Error: Check symbol names against your broker's market watch.");
                Stop();
            }
            
            Print("cTrader Zero-Leverage Buffer Strategy Initialized.");
        }

        protected override void OnTick()
        {
            if (_tradingPhase == 1)
            {
                ExecutePhase1();
            }
            else if (_tradingPhase == 2)
            {
                ExecutePhase2();
            }
        }

        //+------------------------------------------------------------------+
        //| Phase 1: The Zero-Leverage Silver Long                           |
        //+------------------------------------------------------------------+
        private void ExecutePhase1()
        {
            // cTrader natively filters positions by Label and Symbol
            var silverPositions = Positions.FindAll(SilverLabel, _silverSymbol.Name);
            
            if (silverPositions.Length == 0)
            {
                // Entry: Open unleveraged XAGUSD Long
                double volumeInUnits = CalculateUnleveragedSilverVolume();
                
                if (volumeInUnits > 0)
                {
                    ExecuteMarketOrder(TradeType.Buy, _silverSymbol.Name, volumeInUnits, SilverLabel, 0, 0, "Phase 1: Buffer Build");
                    Print($"Phase 1 Initiated: Unleverage Silver Long opened. Units: {volumeInUnits}");
                }
            }
            else
            {
                // Exit: Monitor net profit (includes swap & commissions natively in cTrader)
                var position = silverPositions[0];
                
                if (position.NetProfit >= SilverTargetUSD)
                {
                    ClosePosition(position);
                    
                    _riskBufferUSD = position.NetProfit;
                    _phase2StartEquity = Account.Equity;
                    _tradingPhase = 2;
                    
                    Print($"Phase 1 Complete. Buffer Locked: ${_riskBufferUSD}. Transitioning to Phase 2.");
                }
            }
        }

        //+------------------------------------------------------------------+
        //| Phase 2: The "House Money" Transfer                              |
        //+------------------------------------------------------------------+
        private void ExecutePhase2()
        {
            // Risk Check: Flush all trades if buffer is depleted
            if (Account.Equity <= (_phase2StartEquity - _riskBufferUSD))
            {
                CloseAllForexTrades();
                Print("Risk buffer depleted. Reverting to Phase 1.");
                
                _tradingPhase = 1;
                _riskBufferUSD = 0.0;
                return;
            }

            // --- CORE SCALPING ALGORITHM GOES HERE ---
            
            var forexPositions = Positions.FindAll(ForexLabel, _forexSymbol.Name);
            
            if (forexPositions.Length == 0)
            {
                // Placeholder execution block.
                // Note: Convert your lot parameter to volume in units for cTrader execution.
                // double volumeInUnits = _forexSymbol.QuantityToVolumeInUnits(ForexLotSize);
                // ExecuteMarketOrder(TradeType.Buy, _forexSymbol.Name, volumeInUnits, ForexLabel, 0, 10, "Phase 2 Core Scalp");
            }
        }

        //+------------------------------------------------------------------+
        //| Calculate 1:1 Unleveraged Volume (Units)                         |
        //+------------------------------------------------------------------+
        private double CalculateUnleveragedSilverVolume()
        {
            if (_silverSymbol.Ask == 0) return 0;

            // 1:1 Leverage constraint: Notional Exposure = Total Account Balance
            // In cTrader, volume is calculated in units (ounces for XAG), making this much simpler than MQL.
            double maxAffordableUnits = Account.Balance / _silverSymbol.Ask;
            
            // Normalize sizing down to the broker's required step increment (e.g., 50 oz, 1 oz)
            double normalizedVolume = _silverSymbol.NormalizeVolumeInUnits(maxAffordableUnits, RoundingMode.Down);
            
            if (normalizedVolume < _silverSymbol.VolumeInUnitsMin) 
                normalizedVolume = _silverSymbol.VolumeInUnitsMin;
                
            if (normalizedVolume > _silverSymbol.VolumeInUnitsMax) 
                normalizedVolume = _silverSymbol.VolumeInUnitsMax;
                
            return normalizedVolume;
        }

        //+------------------------------------------------------------------+
        //| Emergency/Buffer Stop Logic                                      |
        //+------------------------------------------------------------------+
        private void CloseAllForexTrades()
        {
            var forexPositions = Positions.FindAll(ForexLabel, _forexSymbol.Name);
            
            foreach (var position in forexPositions)
            {
                ClosePosition(position);
            }
        }
    }
}

[PTScalper]

Key C# / cTrader Advantages in this Build:

Positions.FindAll() Array Filtering: Notice how the for loops counting open tickets are completely gone. cTrader allows you to fetch an array of specific positions filtered cleanly by the Label name and Symbol.

Native Unit Normalization: The CalculateUnleveragedSilverVolume() function is much lighter. Because cTrader calculates everything in base units (ounces of Silver) rather than arbitrary broker lot fractions, we can directly divide your balance by the ask price and use the built-in NormalizeVolumeInUnits() function with RoundingMode.Down to handle the math safely.

NetProfit Property: MT4/MT5 requires manually adding up the trade profit, swap, and deal-based commissions. cTrader's position.NetProfit is a live, fully consolidated double.

[PTScalper]

Porting this to TradingView requires a slight paradigm shift. Unlike MT4 or cTrader, which have direct access to your broker's entire market watch and can simultaneously manage orders across different assets in real-time, Pine Script evaluates strictly bar-by-bar against the specific chart it is attached to.

To make this work in Pine Script, you must attach the strategy to your core forex scalping pair (e.g., EURUSD). The script will then use request.security() to look up the XAGUSD price data, mathematically model the Phase 1 silver buffer in the background, and unlock the native strategy.entry() functions for your forex pair only when the simulated silver buffer is secured.

Here is the Pine Script (v5) implementation:

Code: Select all

//@version=5
strategy("Two-Phase Buffer Strategy", overlay=true, initial_capital=10000, margin_long=100, margin_short=100)

// --- Input Parameters ---
silverSym = input.symbol("OANDA:XAGUSD", title="Phase 1: Silver Symbol")
bufferTarget = input.float(50.0, title="Phase 1: Buffer Target (USD)")
forexLotSize = input.float(1.0, title="Phase 2: Forex Lot Size")

// --- State Variables (Persist across bars) ---
var int tradingPhase = 1
var float riskBufferUSD = 0.0
var float phase2StartEquity = 0.0

// Silver Virtual Position Tracking
var float silverEntryPrice = na
var float silverUnits = 0.0

// --- Fetch Silver Data ---
// Pulls the close price of Silver for the current timeframe
silverClose = request.security(silverSym, timeframe.period, close)

//+------------------------------------------------------------------+
//| Phase 1: The Zero-Leverage Silver Long (Modeled)                 |
//+------------------------------------------------------------------+
if tradingPhase == 1
    // Entry: Log the price and calculate unleveraged volume
    if na(silverEntryPrice)
        silverEntryPrice := silverClose
        // 1:1 Leverage constraint: Notional Exposure = Total Account Balance
        silverUnits := strategy.equity / silverEntryPrice 

    // Exit: Monitor virtual PnL of the Silver position
    if not na(silverEntryPrice)
        currentSilverPnL = (silverClose - silverEntryPrice) * silverUnits
        
        if currentSilverPnL >= bufferTarget
            riskBufferUSD := currentSilverPnL
            // Lock in the new equity baseline for Phase 2
            phase2StartEquity := strategy.equity + riskBufferUSD 
            tradingPhase := 2
            
            // Reset virtual silver position
            silverEntryPrice := na 
            silverUnits := 0.0

//+------------------------------------------------------------------+
//| Phase 2: The "House Money" Transfer                              |
//+------------------------------------------------------------------+
if tradingPhase == 2
    // Risk Check: Flush all trades if buffer is depleted
    if strategy.equity <= (phase2StartEquity - riskBufferUSD)
        strategy.close_all(comment="Buffer Depleted: Emergency Flush")
        tradingPhase := 1
        riskBufferUSD := 0.0

    // --- CORE SCALPING ALGORITHM GOES HERE ---
    
    // Placeholder execution block (e.g., Simple Momentum Cross)
    fastSMA = ta.sma(close, 10)
    slowSMA = ta.sma(close, 20)
    qtyUnits = forexLotSize * 100000 // Convert standard lots to units
    
    if strategy.position_size == 0
        if ta.crossover(fastSMA, slowSMA)
            strategy.entry("Phase 2 Long", strategy.long, qty=qtyUnits)
        else if ta.crossunder(fastSMA, slowSMA)
            strategy.entry("Phase 2 Short", strategy.short, qty=qtyUnits)
            
    // Placeholder exit logic
    if strategy.position_size > 0 and ta.crossunder(fastSMA, slowSMA)
        strategy.close("Phase 2 Long")
    if strategy.position_size < 0 and ta.crossover(fastSMA, slowSMA)
        strategy.close("Phase 2 Short")

//+------------------------------------------------------------------+
//| Visualizing the Phases on the Chart                              |
//+------------------------------------------------------------------+
// Dims the background during Phase 1 (Building Buffer)
bgcolor(tradingPhase == 1 ? color.new(color.silver, 90) : na, title="Phase 1 Background")

// Plot transition markers
plotshape(tradingPhase == 2 and tradingPhase[1] == 1, title="Phase 2 Start", style=shape.labelup, location=location.belowbar, color=color.green, text="BUFFER LOCKED", textcolor=color.white, size=size.small)
plotshape(tradingPhase == 1 and tradingPhase[1] == 2, title="Buffer Depleted", style=shape.labeldown, location=location.abovebar, color=color.red, text="BUFFER LOST", textcolor=color.white, size=size.small)

[PTScalper]

Pine-Specific Workarounds Explained:

State Persistence (var keyword): In MQL or C#, variables retain their values natively. In Pine, standard variables reset on every single candlestick. Using the var keyword forces TradingView to carry the tradingPhase and riskBufferUSD values forward across time.

Virtual Modeling for Phase 1: Because you cannot execute a real strategy.entry on XAGUSD while running the script on EURUSD, Phase 1 tracks silverEntryPrice and calculates the PnL mathematically. This perfectly simulates the unleveraged hold and transition sequence for accurate historical backtesting.

Visual Debugging: I added a bgcolor and plotshape block at the bottom. Your EURUSD chart background will lightly tint silver while it is waiting for the buffer to build, and flash green/red tags when the phases transition so you can visually verify the exact candlesticks where you switched from "Market Money" back to "Capital Risk."

To automate this for live execution, you will need to bypass the built-in broker integrations and use Webhooks, routing JSON payloads directly to your local server or a bridge (like PineConnector).