The latest standalone (previous version not tested) API is always one tick behind the regular JForex Live Client.

When did i test it? Right now over the last hour. Multiple restarts etc

How did i test it?

Simple JForex Standalone blank strategy with the following put in onTick():

if(instrument.equals(Instrument.EURUSD)) {
System.out.println("jforex: EURUSD tick: "+tick.getBid());
}

Client Strategy:

if(instrument.equals(Instrument.EURUSD)) {
console.getOut().println("jforex client: EURUSD tick: "+tick.getBid()+" - "+tick.getTime());
}


I then put the Client Strategy / Market Overview / Chart of the JForex Live client besides the console output and the jforex api is _always exactly_ one tick behind:

e.g. right now (tick.getBid + tick.getTime) - client = live client strategy (same as marketview + charts), api = latest standalone api


#1 jforex client: EURUSD tick: 1.34653 - 1359329803839
#1 jforex api: EURUSD tick: 1.34651 - 1359329799671

#2 jforex client: EURUSD tick: 1.34657 - 1359329814081
#2 jforex api: EURUSD tick: 1.34653 - 1359329803839

#3 jforex client: EURUSD tick: 1.3466 - 1359329814320
#3 jforex api: EURUSD tick: 1.34657 - 1359329814081

#4 jforex client: EURUSD tick: 1.3466 - 1359329814380
#4 jforex api: EURUSD tick: 1.3466 - 1359329814320

#5 jforex client: EURUSD tick: 1.34662 - 1359329814909
#5 jforex api: EURUSD tick: 1.3466 - 1359329814380

#6 jforex client: EURUSD tick: 1.34662 - 1359329816767
#6 jforex api: EURUSD tick: 1.34662 - 1359329814909

As one can see the standalone api gets an "onTick" event at the same time as the client api (grouped numbers arrive exactly at the same time both in client/standalone) but the standalone api gets an old (previous tick) sent instead of the current one.

The api will only receive the last tick once the live client receives a new tick. The grouped numbers arrive at the same time so this is probably a simple index bug in the datafeed server being off by 1 or reading from a datastructure that has not been updated with the latest tick yet for the standalone api.

This can easily be seen in slow ticking illiquid times like now where the api will always be seconds behind the live client.

I observe exactly the same thing, and was about to report it as an error in the horizontal drawing on the chart but now I see that it is a deeper issue, probably not related to graphics.

Also I did not notice this in the API 2.7.7 but I am not sure, only in the now current API 2.7.8

In my attached screenshot, the drawn lines are frequently not the same as the standalone chart's lines for Bid and Ask price. EURUSD Tick chart in API 2.7.8 standalone client strategy. The tick chart is created by the standalone client, and the Strategy module just draws on that same chart.

It appears that delivery of the event to onTick() in the strategy module is the issue, as the standalone chart's pricing may be correct and up to date (but I am not sure). It might be the strategy onTick() is "one tick behind" exactly as the original poster has observed, but the standalone chart pricing might be correct and up to date.

The attached calculated the Bid/Ask spread as 0.5 pips, but the chart is showing a spread of 0.4 pips. This is probably due to the data feed lag suggested by the original poster.

Please look into this issue.

HyperScalper

Is there any workaround to this? I am just learning the standalone API client approach.

Isn't there some way for me to implement and subscribe an IFeedListener in my standalone client, without using the IStrategy construct?

I see IContext.subscribeToFeed(IFeedDescriptor feedDescriptor, IFeedListener feedListener) but how do I get a context reference in the standalone client, outside of the IStrategy callback events, such as void onStart(...) ?

HyperScalper

This is not a graphics issue. This is a an API and / or pricefeed server issue. And people listen up this is serious.

###

Everyone (experiencing this - which should be anyone...) trading using the standalone API is trading based on old prices! Do not execute trades / chart with the standalone API till Dukascopy finally comments on this / fixes it! You are trading prices that do not exist anymore! You could just as well trade based on your next weather forecast. Price might already have ticked 10 pips higher / lower than what you base your trading decisions on!

###

It would be nice to get some acknowledgement and an emergency fix from Dukascopy since as i said - the standalone api is useless for trading until this bug is fixed! This is no "can be fixed sooner or later" type of bug.

I agree, this is an urgent bug to fix. However, I do extremely precise scalping and, so long as the market is not completely stagnant, it's workable even missing the latest tick. I'm doing trigger-based Euro scalping successfully using it right now ! (Yeah, I know it ain't correct but I doubt people do as precise/fast scalping as I do, and it's usable.)

BUT... having said that, no doubt this is a bad thing and I would certainly like it to be fixed with URGENCY.

Even providing a privately available "fixed jar" if it's isolated to a single jar, would satisfy me for the time being.

HyperScalper

Hello,

I was wondering about the same effect when I tried to retrieve the current spread. I always get the spread one tick before the latest. I checked that with bid and ask and the results provided by the API are exactly the once before the latest tick seen on the client 'order entry' - mask (see screenshot).
As I am new to Ducascopy I thought it might be some bad coding on my side, but it seems that it is an issue, isn't it?

Please correct me if I am wrong. Thanks a lot in advance.

package com.myCompany.myStrategies;

import com.dukascopy.api.*;
import java.awt.Color;
import java.awt.Font;
import java.util.Set;

public class onTickCalcSpread implements IStrategy {

    public IChart chart;
    private IContext context;
    String spread;
    private Font font = new Font("", Font.BOLD, 16);

    @Override
    public void onStart(IContext context) throws JFException {
        this.context = context;
    }

    @Override
    public void onTick(Instrument instrument, ITick tick) throws JFException {
        for (IChart chart : this.context.getCharts(instrument)) {
            spread = String.format("%.1f", (tick.getAsk() - tick.getBid()) * Math.pow(10, instrument.getPipScale()));
            chart.setCommentFont(font);
            chart.setCommentColor(Color.RED);
            chart.comment("Spread: " + spread + "\n" + "Ask: " + String.format("%.5f", tick.getAsk()) + "\n" + "Bid: " + String.format("%.5f", tick.getBid()));

        }
    }

    @Override
    public void onBar(Instrument instrument, Period period, IBar askBar, IBar bidBar) throws JFException {
    }

    @Override
    public void onMessage(IMessage message) throws JFException {
    }

    @Override
    public void onAccount(IAccount account) throws JFException {
    }

    @Override
    public void onStop() throws JFException {
        for (Instrument instr : Instrument.values()) {
            Set<IChart> charts = context.getCharts(instr);
            for (IChart chart : charts) {
                chart.comment("");
            }
        }
    }
}

Yes spread change = ask change in relation to current bid and results in an onTick call. Since you always get an old tick and not the current tick your spread displayed is also wrong (the spread from one tick before).

Write your account manager, support whatever. It is very annoying that there is no fix / confirmation at all here again. This can easily be reproduced / is affirmed by multiple people and a total dealbreaker since a pricefeed that is old ... is no pricefeed...

Especially scalpers / breakout / news traders - you might still make a win but you will almost always be like 0.3-X pips late to the game -> decrease your win / increase your loss. Since you are with momentum most of the time this is not 50/50 with/against you. It will almost always be against you. Your loss is your counterparties win. Who is your counterparty?

Since the ticks are correct / just old and always exactly one late this is almost certainly a very simple wrong index / too early access of the dynamic data structure / dbase that holds the latest ticks on server side. In this case we probably won't see a fix till the weekend maintenance window...

I assumed this would be a just a client-side API bug issue? Seems to me it needn't involve the server side...

HyperScalper

Well depends, logic would say pricefeed server pushes a new event ("new tick") to each connected client which caches it / whatever and calls onTick() for every strategy with it.

- tick received from server by client
- tick cached + unmodified copy / whatever handed down to every strategy onTick()

-> error in index lookup would be server side

If it just hands down the received tick to every strategy then its a server side wrong index issue.

If it calls the strategy onTick from the local cache kinda like

- tick received from server by client
- tick put in local history cache
- call onTick with last tick _from cache_ kinda like "call onTick with either index X or simply latest tick position from cache"

then the wrong index issue is within the client side api yes.

Thinking further i agree its probably a client side issue since for strategy consistency with the history cache interface etc the tick probably gets inserted into local history cache first and then onTick is called with get index X or latest tick so that the tick is consistent with any history / data access within onTick.

I believe I have found a partial workaround for this BUG, in my fairly simple situation. If anyone is desperate to workaround this issue, then you could contact me or figure it out from the information below:

So, I would like to answer my own question Yes, I believe there is a temporary workaround.

CAN AN IFeedListener RECEIVE MARKET DEPTH? SOMEONE PLEASE ADVISE ME.
This workaround may not have access to market depth, depending on how the IFeedDescriptor is defined, and maybe it can't receive Depth of Market... ? But inside Bid/Ask is no problem in my experience. ITick did not appear populated with Market Depth info. What did I do wrong? Tried implementing both IFeedListener and ITickFeedListener but couldn't see market depth in ITick.

It appears that an IFeedListener does not experience the BUG, and that it is only ticks delivered to IStrategy.onTick which exhibit the BUG. On a hunch, I did the following:

I was able to get IContext using an unorthodox technique, and to subscribe as an IFeedListener, without being inside of an IStrategy. Since it is IStrategy.onTick(...) which exhibits the BUG.

Using information found in this post,
viewtopic.php?f=65&t=48713

where an "empty strategy" was used in order to obtain some information...
I implemented an empty Strategy module in order to obtain the IContext handle when the onStart was called.

   // code snippets in isolation, for information only
            // want to get IContext so try to do it this way
            getClient().startStrategy(new EmptyStrategy() {
               @Override
               public void onStart(IContext contextArg) throws JFException {
                  context = contextArg;
                  //indicators = contextArg.getIndicators();
               }
            });
            //the strategy has been started in another thread, thus the onStart has not been called at this point yet

            //wait max
            int i = 10;
            while (context == null && i > 0) {
               Thread.sleep(1000);
               i--;
               System.out.println("Context is: "+(context==null?"NULL":"AVAILABLE"));
            }
            if (context!=null) {
               System.out.println("Set HyperScalperConsoleSA as a feed listener...");
               context.subscribeToFeed(ticksFeedDescriptor, this);
            }


   class EmptyStrategy implements IStrategy {

      @Override
      public void onStart(IContext context) throws JFException {}

      @Override
      public void onTick(Instrument instrument, ITick tick) throws JFException {}

      @Override
      public void onBar(Instrument instrument, Period period, IBar askBar, IBar bidBar) throws JFException {}

      @Override
      public void onMessage(IMessage message) throws JFException {}

      @Override
      public void onAccount(IAccount account) throws JFException {}

      @Override
      public void onStop() throws JFException {}
      
   }

Then, having the IContext handle, I was then able to register the API client as an IFeedListener.

   // IFeedListener interface
   @Override
   public void onFeedData(final IFeedDescriptor feedDescriptorArg, final ITimedData timedDataArg) {
      if (!(timedDataArg instanceof ITick)) return;
      Instrument instrument = feedDescriptorArg.getInstrument();
      if (!selectedInstrument.equals(instrument)) return;
      ITick tick = (ITick)timedDataArg;
// HACK: Strategy module exposes a boolean indicating it is ignoring its onTick
//  and listenening to onTickExternal instead ...  (very temporary workaround)
      if (smartOrderHelperStrategy!=null && smartOrderHelperStrategy.EXTERNAL_TICK) {
         context.executeTask(new ExternalTickTask(tick));
         // just marshal and dispatch, with no wait
      }
      double bidPrice = tick.getBid();
      double askPrice = tick.getAsk();
      // write out price feed
      System.out.println("onFeedData bid: "+bidPrice+" ask: "+askPrice);
      return;
   }
   
   final class ExternalTickTask implements Callable<Void> {
      ITick tick;
      public ExternalTickTask(final ITick tickArg) {
         tick = tickArg;
      }
      public Void call() {
         try {
            smartOrderHelperStrategy.onTickExternal(selectedInstrument, tick);
         }
         catch(Exception e) {
            e.printStackTrace();
         }
         return null;
      }
   }
   

By having a handle to my "real" strategies, and having them ignore their own "void onTick(...)" and delivering ticks to them using a void onTickExternal(...) which I defined, I was able to use my IFeedListener to deliver ticks to my Strategies.

Of course it's best to marshal that data using IContext.executeTask(task) so that you are in the correct thread context. Perhaps, simply delivering the data to the strategies in the context of the void onFeedData event is sufficient.

The result is that this appears to be a (temporary) workaround to the issue, and to deliver the "current" tick CORRECTLY.

But please do fix the IStrategy.onTick(...) bug as soon as possible.

HyperScalper

Ok i can confirm this is a client side API bug. I have modified the maven pom.xml to use the live client api version 2.7.5 and the bug does not exist there anymore. It now ticks correctly so this is a bug in the last / > 2.7.5 api versions. I have not tested 2.7.6 yet.

Hey Genius (yes, you, "yoursong") just kidding... You know that workaround I proposed, with IFeedDescriptor, where I got Bid/Ask inside market, but I couldn't get Market Depth?
Have any ideas about that? In other words, is Market Depth available ONLY inside an IStrategy.onTick(...) type of callback? Shouldn't any IFeedListener get Market Depth ???
Doesn't make any sense to me. Is there a bug in IFeedDescriptor/IFeedListener re: Market Depth being missing for standalone API clients? The ITimedData cast to ITick doesn't seem to have the depth populated, unless I'm mistaken..... This is where the IFeedDescriptor is configured for Tick feeds. Please respond, I'm so lonely....
HyperScalper

Hi,

could you be so kind and give me some advise how to change the jforex-API version from 2.7.8 back to 2.7.5?

As of now I did the following (for more details please take a view to the attached screenshots):

1. I downloaded the appropriate APIs (jforex-API-2.7.5 and jforex-API-2.7.5-sourec) from Dukascopy repository

2. I modified the maven POM.xml in netbeans and replaced the jforex-API-2.7.8 and the jforex-API-2.7.8-sources in the dependencies and in the appropriate directory (C:\Users\[username]\.m2\repository\com\dukascopy\api\JForex-API). I also changed in that directory the maven-metadata-local.xml file as well. After all I rebuild and recompiled the strategy

But at the end it seems nothing has changed. Restarting JForex and netbeans as well as erasing the java cache seems not to help. I still have the Ask / Bid data of the tick before the latest. Also JForex help-about window mentioned the client side is still on 'JForex API ver. 2.7.8'

Do you have an idea what else needs to be done to revert back to version 2.7.5 client side API?

Thanks a lot in advance, Hugoman.

hyperscalper: I haven't really used the feeddescriptor / market depth stuff off jforex. I just use ontick/onbar to power my own charting app and wouldn't really rely on this DOM. Makes only sense in my opinion if you fetch it from a major exchange style house.

hugoman: I use the maven plugin in eclipse. Modify pom.xml to match following versions:

...
<artifactId>JForex-SDK</artifactId>
<version>2.21</version>
...
<groupId>com.dukascopy.dds2</groupId>
<artifactId>DDS2-jClient-JForex</artifactId>
<version>2.21</version>
...
<groupId>com.dukascopy.api</groupId>
<artifactId>JForex-API</artifactId>
<version>2.7.5</version>
<classifier>sources</classifier>

According to wiki it is important that jforex / dds2client match. 2.21 should be 2.7.5 match.

###

What i find a bit disturbing is that this thread has been moved to knowledge base without any bug / will be fixed comment.

The issue is under investigation.

Believe me, for micro trend analysis, for micro scalping, this Dukascopy DOM
(when processed correctly) provides amazingly accurate trend predictions.
Now, if you're interested in a DOM which is more than a couple of PIPs wide,
then you may have no choice but to seek it elsewhere. (I've requested a wider
DOM but so far no confirmation it's being worked on.)
Don't be so quick to dismiss the value of the DOM, but you gotta know how to interpret it
For predications from 10 seconds out to 10 -15 minutes JForex DOM information works but,
again, you have to know what you're looking for... and it depends upon your desired
trade frequency or turnaround.
HyperScalper

Thanks a lot.

Sure not picking on DOM. I'm just used to different POM although yes you have to hand over a lot more cash to get "more" DOM. The pricefeed is priceless though (for charting at least more than tenfore/cqg).

Thanks a lot for your help, yoursong. I really appreciate it.

I was mixed up with the different versions. Changing the version of JForex-SDK consistently from 2.23 to 2.21 and JForex-API from 2.7.8 to 2.7.5 the client side API returns with the latest tick as shown in the chart. I did also a short test with JForex-API 2.7.7 and with JForex-SDK 2.22.1 which also returns the latest tick.

Thanks API-Support for investigating.

Regards, Hugoman

Regarding this and similar issues, when we wish to revert to a prior API version...

Where are the prior archived versions of JForex-SDK.zip located, please?

Or is the preferred method to use the Maven repository?

Thanks for any tips. I'm new to Maven project structure and procedures.

HyperScalper