TheEconomist's Forex Arbitrage Blog

Finally, after some work, the blog is back in business, and with a new address : http://mqlmagazine.com

First of all, for who doesn't know what swaps are, they are implementation of differential interest rates. We aren't going to present here the implementation of swaps starting from the differentials, but the purpose of the article is to show how the swaps may be used to make money with a small amount of risk.

Swap Arbitrage, as a hedging for interest technique, is another application of Kreslik currency rings: this time there is no need for FPI calculation or generation of virtuals. All it matters is that the currency ring to be correctly placed, and to generate interest by its simple existence. I called it "Swap Arbitrage", because, if we cut out the forex impact, which is usually fixed due to hedging, it's like buying lower and selling higher swaps. The tinier the results, the more risky Swap Arbitrage is, because the swaps need longer time to recover spread loss, time in which fundamental events may alter the interest rates.

1. Generating all the possible versions of available Kreslik rings on a broker

======================================================

In my previous article about the Intercross Arbitrage I covered some BcLib functions helpful in reading MetaTrader content. The first function that needs to be called is GetSymbolsAppendix() to retrieve the symbols appendix, then the GetCurrenciesAndPairs() to get available currencies and pairs. The think pattern of this strategy is the one from Triangular or N-angular Arbitrage. We suppose that we have funds denominated in a currency, that we sell for the next proposed one, and so on, until the ring is completed. This would be hard to implement if we'd use directly the pairs. So we start using the currency list available in UsedCurrencies[] . Suppose we have n currencies (in fact, CurrenciesNo). Every one of them may be , or be not, in a currency ring. Thus we have 2^n combinations. Of course the 2^n include invalid rings, such as 0 , which includes no currency, and others with one or two currencies inside. These are sent to scrapyard and we focus on almost valid currency rings with at least three currencies. I said almost because at the time of their generation we don't know that the pairs to link up the currencies exist for real. Generation is simple, by using a simple cycle from 0 to (2^n)-1 and converting the number to binary, then completing the result with leading zeros. Say for example UsedCurrencies[] has EUR, USD, GBP, JPY and CHF (only these five). Then for example 13 would be translated to binary as 1101, completed with leading zeros to 01101 (to be five digits length), and then we can read the what the 1s mean: USD, GBP and CHF. Once that we have this combination, we could then permutate it to generate the same ring from all possible directions. Then we test each resulted ring for validity (if all pairs exist (of course, if the ring has three currencies, a test on original combination is enough, if it has more, there must be a test on each permuted combination). Once valid, we calculate the overall swap, and, if posible, we keep its combination and permutation numbers on hand (I couldn't generate arrangements, nor combinations directly ; arrangements are nothing more than permuted combinations). After studying all possible combinations or only some of them (say only 3-currency rings) we may have already a best ring, which is the maximum that can be got in given conditions. If there is no best ring, swap arbitrage is impossible.

Powerful BcLib functions to achieve this:

string ConvertTo(int base,int number)

The function converts the number in given base. It's reverse function is int ReconvertFrom(int base,string number) that converts back to base 10.

string Padl(string s,int total,string fillwith)

The function fills string <s> with <fillwith> strings (intended to be chars) to fill up the total length; similar functions: Padr and Padc. These functions originate from FoxPro.

void GenPermutation(int n,int elem,int &perm[])

Generates the permutation <n> (0 - based) of <elem> elements inside array perm. Array will contain numbers from 1 to n.

The opposite of this function is int FindPermutation(int elem,int perm[]) , which will return given's permutation index.

bool ContractExists(string symbol)

Returns true if given symbol exists in the datafeed. It's runtime based, doesn't look up the UsedPairs[] as it can be used for any symbol, not only forex pairs.

bool ContractIsTraded(string symbol)

This is an older function, written by me before I realised MarketInfo(...,MODE_TRADEALLOWED) is available. Now the function will ultimately return MODE_TRADEALLOWED inquiry, however this aspect is a bit controversial, although MODE_TRADEALLOWED inquiry may return False when trade context is busy, so when the contract is really traded.

This is a code excerpt from the SwapFinder (one of the first implementations of this algorithm):

for (icomb=maxim;icomb>=0;icomb--)
 {
 image=Padl(ConvertTo(2,icomb),CurrenciesNo,"0");
 crrcies=Occurs("1",image);
 valid=false; 
 if (crrcies>=3&&crrcies<=maxcrrcies)
	{		 
	maxperm=Factorial(crrcies)-1;
	combimg="";
	for (iimg=0;iimg<CurrenciesNo;iimg++)
	   {
	   if (StringElement(image,iimg)=="1")
		   combimg=StringConcatenate(combimg,UsableCurrencies[iimg]," ");
	   }	   
   WriteLn(StringConcatenate("Studying ",combimg," having ",DoubleToStr(maxperm+1,0)," permutations"));
   for (iperm=0;iperm<=maxperm;iperm++)
	   {
	   ROA=-1;
	   ROE=-1;
	   valid=IsConfigValid(image,iperm,crrcies,Contracts,Ops);
	   if (valid==True)
		  {
		  EstablishRing(crrcies,Contracts,Ops,Volumes,Usage,TotalUsed,Swaps,Interests,NormalROA,WeightedROA,ROA,ROE,FXResult,FinalROE,False);

As you see, the code is not complete, as none of the for cycles is completed; See how <image> is made up by ConvertTo() and Padl() , number of currencies is counted in <crrcies>, then currencies are extracted in the <iimg> cycle (only to be displayed), then permutations are being generated inside the <iperm> cycle, upon validation by IsConfigValid() function, and finally ring is being constructed by the EstablishRing procedure.

2. The mysterious realm of the swaps

============================

The swaps implementation in MetaTrader was always a mystery: the OrderSwap() function works ex-post, it retrieves the total interest cashed/payed on a order. The only way of knowing before is by using MarketInfo's MODE_SWAPLONG and MODE_SWAPSHORT. However, what it gives is a mysterious "swap". Is it an interest rate ? NO. Is it an interest ? NO. Ok. Enough fooling around with "Let's twist again". Let's see what it really is.

First of all, the result meaning is given by MODE_SWAPTYPE inquiry:

MODE_SWAPTYPE inquiry answer : 0

Metaquotes documentation : in points;

BcLib coverage: Yes;

Meaning: In pips;

Behaviour: the most stable ever seen;

Broker examples: ATC Brokers, Finex, FXLQ

==============================================

MODE_SWAPTYPE inquiry answer : 1

Metaquotes documentation : In the symbol base currency

BcLib coverage: No*

Meaning: In the first currency of the pair

Behaviour: Unknown,

but probably jumpy due to needed conversion in that currency

Broker examples: FXLQ recently (yes they have them different)

==============================================

MODE_SWAPTYPE inquiry answer : 2

Metaquotes documentation : by interest

BcLib coverage: No

Meaning: Unknown

Behaviour: Unknown

Broker examples: Never reported in wild

==============================================

MODE_SWAPTYPE inquiry answer : 3

Metaquotes documentation : In the margin currency

BcLib coverage: Yes

Meaning: In pips of the account currency

Behaviour: Very unstable

Broker examples: InterbankFX, FXDD

==============================================

The Swap2Interest_Volume from BcLib converts the swap to interest on a given volume (not lot). Useful when building swap strategies because you can find the actual swap before it would come.

*Not in the last version of BcLib. Find and replace the Swap2Interest_Volume function with the next body for this swap type to be included:

double Swap2Interest_Volume(double volume,int swapmode,string contract,string appendix)
 {  
 double m_tick;
 double m_lotsize;
 double swap;
 double gc;
 double res;
 if (PairsNo==0)
GetCurrenciesAndPairs(appendix);
 string contractf=StringConcatenate(contract,appendix);
 int swt=MarketInfo(contractf,MODE_SWAPTYPE);
 if (swt!=0&&swt!=1&&swt!=3)
{
 if (BcLibAlerts==True)
	Alert("Swap2Interest***** : swap type "+DoubleToStr(swt,0)+" not implemented !");
 return(0);
}
 if (swapmode==MODE_SWAPLONG||swapmode==OP_BUY||swapmode==OP_BUYLIMIT||swapmode==OP_BUYSTOP)
 swap=MarketInfo(contractf,MODE_SWAPLONG);
 else
 swap=MarketInfo(contractf,MODE_SWAPSHORT);
 if (swt==0)
{
 m_tick=MarketInfo(contractf,MODE_TICKVALUE);
 m_lotsize=MarketInfo(contractf,MODE_LOTSIZE);
 return(swap*m_tick*(volume/m_lotsize));	 
}
 if (swt==1)
{
 m_lotsize=MarketInfo(contractf,MODE_LOTSIZE);  
 gc=GetCurrency(StringSubstr(contractf,0,3),AccountCurrency(),appendix);
 res=swap*gc*(volume/m_lotsize);
 if (gc==0)
   {
   if (BcLibAlerts==True)
	 Alert("Swap2Interest***** : could not convert swap type 1 for "+contractf+" as GetCurrency() failed! Check contract and appendix!");	 
   }
 return(res);
}
 if (swt==3)
{
 m_lotsize=MarketInfo(contractf,MODE_LOTSIZE);	 
 return((volume*swap)/m_lotsize);	 
}
 }

You can easily see in the code how the swap types were implemented:

Type 0: swap*m_tick*(volume/m_lotsize)

Type 1: swap*gc*(volume/m_lotsize), where gc is the first currency of the pair converted to account currency

Type 3: (volume*swap)/m_lotsize , similar to type 0 but without multiplicating with the tick value;

Picture of the SwapFinder_script running on ATC Brokers:

http://img222.imageshack.us/img222/2171/pictureofswapfinderscricm4.jpg

SwapFinder parameters:

extern int MarginUsage=90;

extern int MaxCurrenciesUsed=3;

extern bool JustTesting=False;

extern int Slippage=3;

extern bool ShowNegatives=False;

MarginUsage - the percent of the margin (or the leverage) that's used for the trades altogether;

MaxCurrenciesUsed - for 0, scans all the combinations (from 3 to n) currencies; for another value, scans combinations having from 3 to that value;

JustTesting - is a safety measure; it will trade only when the script is allowed to trade from the properties and JustTesting is set to True;

Slippage - trading slippage admitted;

ShowNegatives - if true, will display financial data gathered on negative swap rings too.

Again, be cautious about the MarginUsage. Don't set it too to near 100%, as your effective margin during initiation of trades might get under the required margin and you would run out of funds before completion of trades. Also, be careful that in dangerous situations broker's datafeed may be damaged (the problem I've been talking on the Intercross Arbitrage article) and you won't be fully hedged, your trades being placed in profit/loss territory until the issue being solved.

How to read the SwapFinder window

Usage - the volume , in account currency , of the trade. Under the usages there is their sum, interpreted as Total Assets

% - the weight of the trade volume in total traded. The trades must be hedged, so the % value must be almost the same at them all equal to (1/no. of trades)*100

Op. - trade direction

Volume - the volume of the trade, in units of the first currency of the pair

Lots - the volume, in lots

Contract - the pair symbol

Swap - the exact swaps for one lot, as answered by MODE_SWAPLONG and MODE_SWAPSHORT inquiries

Interest - the real interest earned/payed on the trade

NormalROA - the ROA (Return on Assets) of the trade as (Interest/Usage * 100) * 365 (later edited)

WeightedROA - the Normal ROA as weighted (by the percent occupied in Total Assets)

ROA is the sum of Weighted ROAs.

ROE (Return on Equity) calculated as ((ROA * Total Assets) / Account Equity) * 100

Forex result = costs of spreads

Final ROE = ROE - Forex result

3. Butterfly : a nonlinear hedge

=======================

Some time ago, as I was playing with pencil on paper drawing currency rings and trying to imagine a different kind of hedge that could make more swaps, I came up with the idea of a butterfly hedge ( because two currency rings with a common currency (common tip) look like the wings of a butterfly). However, two completed currency rings, with or without a common tip, are independant rings. They cannot produce more swaps, as one would be , say the best ring, and the other one, a lesser ring. However, this measure could add more safety to swap arbitrage, as it produces a slight diversification of the "investments" (the two currency rings). If we link up N currencies we obtain a simple , linear , currency ring, where EVERY CURRENCY IS EQUALLY BOUGHT AND SOLD. However, noone says it must be bought and sold once!

http://img166.imageshack.us/img166/8964/butterflyfm1.jpg

This was the first version of the butterfly hedge. The points are currencies. Among them O is mirrored (the two O represent the same currency). Features:

- the Z currency is bought 3 times (OZ, YZ, XZ) and sold 3 times (ZO, ZP, ZQ).

- the O currency is bought 3 times (PO, QO, ZO) and sold 3 times (OZ, OY, OX).

A better version of this hedge would be one without the needless ZO and OZ relationships and still the hedge would be a butterfly, since the "wings" could not work seperately.

Each model has a mirror. Just like any atom from Intercross Arbitrage could have played the role of bid or ask, similar any butterfly can be mirrorized simply by reversing the direction of the arrows.

This model doesn't look like a butterfly at all but it respects the same principles.

Looks like electronic circuitry huh?

http://img514.imageshack.us/img514/2331/rectanglehedgeoe2.jpg

(The double arrowed edges mean that volume , in account currency, is double than the one used on the other edges).

Now I don't say the butterfly hedges are necesarilly better than the currency rings. It may be worse in many situations, but tt's a different way of thinking hedge.

SwapButterfly's parameter list is similar to SwapFinder's. However, in the start(), you must assign UseModel to one of the preexistent models defined, or to a new one.

*TIP ABOUT BROKERS: If you find a swap hole in the broker's datafeed (meaning for one pair the cashed swap is bigger than the payed swap, don't just go long and short simultaneously, as this will alert the broker to repair the datafeed. Better place it as a ring or a butterfly, sure this opportunity will be included in the best provided solution).

As I promised to my readers, I am returning with an article about the "new" currency futures contracts introduced by the non-NFA regulated brokers. Together with arbitrageable commodities, currency futures prove to be some of the most valuable contracts to be found in a broker's datafeed.

1. Basics of Currency Futures

======================

Currency futures are the standardized, transferrable version of currency forwards. Currency forward contracts lock in the price at which an entity can buy or sell a currency on a future date. But how is a currency futures priced?

A spot forex rate is the rate at which two currency amounts are equal : for example, 10000 USD are (at a moment, "spot") equal to 1.230.000 JPY at 123 JPY/USD rate. Since the time value of a currency is given by the interest, the currency futures rate which equalizes them incorporates the differential rate.

Suppose we have two currencies, A and B, both equal now, as A/B = 1 spot rate.

A interest in 20%, while B interest is 5%

so there is a rate which equalizes 1.20 with 1.05 , and that rate is 0.875 , as 1.20 x 0.875 = 1.05

Hence the futures formula:

http://img514.imageshack.us/img514/6458/futuresformulaax8.jpg

In our case, the spot rate didn't had any effect, since it was 1.

We must know 2 elements:

1. The interest rates

2. Futures expiry dates

1. The interest rates

That's an easy one. A reliable source for this can be found here on FXStreet .

2. Futures expiry dates

This can be done in a few ways:

a. Download WHC's MetaTrader. Then point to Market Watch, right click, (Show All if they are not already) , Show All, then Properties, then expand the Currencies top folder.

b. Directly from CME website (see below)

Of course, when you use the formula you must calculate the time to expiry as precise as possible , because it influences the interests put inside the formula.

For example, if we have 90 days to expiry, that 1+C2 Interest Rate % from the formula transforms in 1 + (0.5/100) / 365 x 90 = 1.001232876

Almost forgot: depending on the strategy you'll decide to use, it may be useful to check when the next meetings of the central banks officials will take place and also what's the expectation about the interest rates.

2. Spot-to-Futures Arbitrage

=====================

Since the futures are linked to the spot by the interest to expiry, and futures at expiry equalizes the spot (this equalization is a feature of all futures contracts that have a spot counterpart) there are two possible spot-to-futures arbitrages:

http://img128.imageshack.us/img128/4825/eurusdarbitragebigfa2.jpg

a. exploiting the difference between spot and futures (often called basis) and cashing it in while paying interest on spot position (the "Covered Interest Arbitrage" in finance books) ; or, depending on the broker's feed , the reverse : paying the basis and getting interest on spot position (which is ockward and not likely to happen for real, but never say never)

b. exploiting missalignments of the converted futures to the spot (or of the real futures to the calculated futures , which is the same thing) using interest rates.

However, type b. arbitrage is not as seldom as that picture lets to be understood. You don't have to be a genius to see that a misprice happens not only when futures is on the wrong side, but also when futures is not where it should be: We could also discount (let's call it like that the conversion of futures to spot, even if some futures are discounted, e.g. USDJPY) the futures and see how far is from the real spot. We should also have a neat time conversion on hand to have a continuous time, not a jumpy one (e.g. not the time that decreases by one day when a day passes, but a time in real number format). The discounted futures is calculated using the reversed upper formula (get the spot from the equation to find it out).

Discounted futures to spot basis fluctuation

http://img517.imageshack.us/img517/2136/eurusdarbitrage2te3.jpg

The overlay indicator : DiscountedFutures

The window indicator : DiscountedBasis

As you can see, with 5-6 pips in magnitude of arbitrage windows, you could cover the 4 pip costs of arbitrage (2 pips on EURUSD, 2 pips 6E equivalent commission in pips). But is MetaTrader fast enough? However, with a pretty superior account trading at 1 pip spread it might work smoothly... With a regular case of EURUSD - 6E you could, for example, when DiscountedBasis has a higher value, sell the futures and buy the spot, and close when it reaches a lower than regular value...

Now let's return to the a. arbitrage type ("Covered Interest Arbitrage")

The picture below depicts the basis and swaps consuming reciprocally (in the normal swap rate regime), while the new, swap-free accounts based on brokers arrangements with islamic banks provide new, outstanding arbitrage opportunities:

Parameters : Account equity about 450 USD; Account leverage about 200 ; Margin usage = 90% ;

http://img524.imageshack.us/img524/7725/spottofuturesarbitrageme1.jpg

from Futures.mq4 script

This example was run on WHC (although WHC doesn't offer swap free accounts).

How are the calculations done?

Below is a picture with the implementation made by Beaverhea Financial. Although it's an untrustable broker, the implementation is useful for calculus and demo.

http://img166.imageshack.us/img166/9504/beaverheadfuturesyf1.jpg

The real currency futures implementations on CME

The ones that can be found with brokers are:

CME Euro FX

CME Australian Dollar

CME Canadian Dollar

CME British Pound

CME Japanese Yen

CME Swiss Franc

WHC comes also with these two, but they don't seem to work properly:

CME EC/JY Cross Rate

CME EC/SF Cross Rate

Now the arbitrage is pretty simple to understand if it's about EURUSD and 6E. Provided that EURUSD's lotsize is 100K and 6E's lotsize is 125K, the ratio : EURUSD traded lots / 6E traded lots = 5/4, as 5 x 100K = 4 x 125K to equalize pip movements.

But what if it's a reversed futures, such as USDJPY to 6J ?

This is a calculus example, using the Impeccable Hedge algorithm that powers FPI, Intercross Arbitrage and Swap Arbitrage

We consider:

USD - 5.25%

JPY - 0.25%

USDJPY right before old futures expiry: 123.00

6J right before old futures expiry = 100/123.00 = 0.8130

New futures, in the first moments, with expiry in 3 months:

http://img64.imageshack.us/img64/6761/futurescalculation6jcd5.jpg

Actually tested the formula on june 15 data and it was accurate on a range of 6 pips

(of course I used 92 days period instead of dividing to 4)

Prepairing the hedge : USDJPY spot > transformed USDJPY futures : Sell USDJPY, Sell 6J

Sold 100000 (1 lot) USDJPY @ 123

Sold 100000 USD

Bought 12300000 JPY

Sold 12300000 (0.98 lots) JPYUSD (6J) @ 0.8232 (/100)

Sold 12300000 JPY

Bought = 101253.6 USD

That 1253.6 must be the embedded interest in the futures.

Supposing now USDJPY=127 on expiry ; 6J is right reversed = 0.7874

Sell 100000 USDJPY @ 123 -> (1 pip = 10*100/127 = 7.87 USD) : -400 pips x 7.87 = -3148 USD

Sell 1230000 6J @ 0.8232 -> (1 pip = 12.3 USD) : 358 pips x 12.3 = 4403.40 USD

Result = 1255.40

Supposing now USDJPY=119 on expiry ; 6J is right reversed = 0.8403

Sell 100000 USDJPY @ 123 -> (1 pip = 10*100/119 = 8.40 USD) : 400 pips x 8.40 = 3360 USD

Sell 1230000 6J @ 0.8232 -> (1 pip = 12.3 USD) : -171 pips x 12.3 = -2103.30 USD

Result = 1256.70

As you see, arbitrage holds no matter the direction. And if the regime is swap free, pocket all of it... about 200K USD in traded volume, this would be tradable with a 500 USD account at about 450 leverage! This means more than double!

Of course it is advisable to review articles on central banks monetary policies especially if their meetings happen close to the beginning of futures. Create scenarios about what might happen if interest differential enlarges. Calculate the damage done to the equity, add 20-30 pips or more of market "missalignments" and see at what leverage it is sustainable (also include here the issues about not trading microlots - see the Intercross Arbitrage article). If you're heavy leveraged and faint hearted, better close positions before central bank meetings, and , most important, don't EVER forget to close positions before expiry or your account will likely be blown up due to violent futures shift on expiry change (or hopefully you'll just lose the profit!) . You could even test broker's vigilance by reversing positions with a day before expiry in order to make the entire profit on the expiry shift moment... Whatever, the method is a great progress from leaving the forex madness for a slow paced and profitable trading with controllable risks!

3. Warnings about Attachments

========================

Be very careful about how you set up DiscountedFutures and DiscountedBasis, especially with the interest rates and the expiries!

Look close at the SwapFree parameter when running Futures.mq4 script!

And be extremely careful when running on real accounts! Measure ten times and cut once! The script supposes all margin requirements are the same, however with some brokers margins for futures are bigger. Experiment first on demo.

I thought about this system several months ago. I wasn't able to find a suitable implementation, because I tweaked it to the point I completely screw it up, so I'll put it the way I initially thought it.

Trader's Fallacy: Hey, I can follow that trend and make cash like a pro!

Traders love charts. Perhaps our reason for entering stock , forex or other markets was watching trending markets and simple indicators. The simplest indicator that someone gets in touch with when entering forex or stocks is the Moving Average (MA). Look how beautiful it is:

http://img259.imageshack.us/img259/4120/beautifulmatk0.jpg

You always used the MA as an indicator and always it tricked you! Damn whipsaws!

But the MA is pretty neat. Whatever happens and wherever far the market will go, eventually it will slow down and be catch up by the MA.

Haven't you ever dreamed that the MA to be an asset to hedge against the market itself ? Say go short the market, long the MA, and get profit on cometogether?

Look at the highest peek, it's so far from that 200 values MA at about 183 pips!

But how in the world could we trade that way...?!

The value of a MA is roughly the arithmetic average of the last N values (We consider Simple Moving Average). So if we have N trades, done at these prices, this composite asset will have been traded at about the MA value!

Well, you may say...how we do that? How do we know if we buy the MA and sell the market or we do the reverse ?

I have an answer...Good news and bad news. Starting with the bad news: it's gonna cost. Not a killer cost, but it will be. And the good news: you will be able to trade both ways, without needing to know what will happen and without being whipsawed!

Not knowing what will happen

It's gonna be either BUY or SELL. But until then, it's gonna be both: You construct the moving average, every bar, until it's ready: on every bar, buy and sell the Nth part of the position you take. Once the moving averages, completely hedged of course, will be ready, on every bar you will close the oldest pair buy/sell and place a new pair of buy/sell, keeping the moving average "assets" in line with the moving average itself.

How much it will cost ? Well, you get slipped on both placing and closing trades, and you will pay the spread on both buys and sells. That means that after the first N bars you will have a spread cost of about

2 x spread (for buys and sells)

Any other series of N bars came in will produce this cost, plus the slippage costs:

((2 x average slippage) for opens and closes ) x 2 for buys and closes)

Now once the basis (market minus moving average) jumps over a fixed , predefined value (say 50 pips), we will trigger the "trade": say the market trades at 1.4503 and the moving average is at 1.4320 . That means, sell the market, buy the moving average. We keep the series of BUYS, since its ready, and close the sells. Nothing happens, we were hedged. We place another sell at about 1.4503 , a huge trade, by the volume equal to the series of closed sells. We continue to "refresh" the moving average, replacing the oldest buy with a new entry on every bar. When the market will join the MA, we will have a fixed profit on the SELL side, some profits made by current BUYS and closed profits of the older BUYS. Of course, the extra spread and slippage costs for maintaing buys will be added. We close all trades and start rebuilding the moving average. Until the moving average is finished, no "trading" will be allowed ; at the moment when this is ready, we barely start up waiting for a new "trade".

Problems to think about

1. Enlarged spread

Once you take a "trade" you will be exposed to the basis going higher thus generating virtual losses. Take care not touch the margin call!

2. Broker limits

You need a broker that allows microlots and an outrageous number of trades. More trades possible, the bigger moving averages used, the higher number of pips caught!

3. Market delay

If the market will come together with the MA too late, hedge maintaing costs may be significant!

I'm awaiting comments!