brokerCommand (int Command, intptr_t Parameter): var

brokerCommand (int Command, string Text)

brokerCommand (int Command, var* Parameters)

Parameters:

Returns:

brokerAsset (string Symbol, var* pPrice, var* pSpread, var *pVol)

brokerAccount (string Name, string AccountID, var *pBalance, var *pTradeVal, var *pMarginVal);

brokerRequest (string Path, string Method, string Data): string

brokerTrades (int Filter): int

Remarks:

• Commands marked internal are automatically sent by Zorro to the broker plugin. They need normally not be used in the script. The other commands are not used by Zorro and available to the script. If a command is not supported, it returns 0. Which of the commands are supported can be found on the description page of the broker plugin.
• The SET_PATCH command is always supported since it's handled on the Zorro side. It lets Zorro estimate account and trade parameters, rather than using the values from the broker API. This is required when the broker API calculates those parameters wrong, as was the case for the account balance, equity, and open trade profit in some FXCM API versions. Replacing those parameters has no effect on trading, but on the displayed equity and profit values on the Zorro panel. The estimated equity includes only the profit by trades of the current strategy, and thus is different to the account equity when other systems trade on the same account. The estimated trade result can also differ to the real result due to slippage and rollover.
• For preventing the interruption of a command sequence by another Zorro instance -  f.i. for setting order parameters before sending the order - use either the SET_LOCK command (if available) or the lock function. They work like a Windows Mutex. Before the sequence, use while(0 == brokerCommand(SET_LOCK,1)) wait(5); for waiting until the lock was released, and setting it then. Afterwards, brokerCommand(SET_LOCK,0) releases the lock after sending the command sequence. If SET_LOCK is not supported by the plugin, use the lock/unlock functions in a simular way to lock the part of the code.
• If the script connects to multiple brokers, commands are sent to the broker assigned to trading with the the current asset (SourceTrade).
• Contract chains by GET_OPTIONS or GET_FOP are filled with the following data from the CONTRACT struct, which is defined in include\trading.h:
  time: a null-terminated string of up to 7 chars containing the trading class symbol (if available)
  fAsk, fBid: the ask and bid price (if available)
  fStrike:  the strike price
  fVal: the multiplier (if available)
  Expiry:  the expiration date in YYYYMMDD format
  Type:   the contract type, PUT, CALL, FUTURE, EUROPEAN, BINARY; optionally an exchange identifier coded in the upper 16 bits.
• Trade arrays by GET_TRADES are filled with the following position data (the TRADE struct is defined in include\trading.h):
  nId:  a unique trade identifier (if available)
  nLots: the position amount
  flags:  TR_SHORT for short positions
  fEntryPrice: the average entry price if available; some brokers (IB) multiply the entry price with the options multiplier.
  fStrike: the strike price if applicable
  tExitDate:  the expiration date in DATE format (if applicable)
  nContract:  the contract type if applicable, i.e. PUT or CALL; optionally an exchange identifier coded in the upper 16 bits. If the FUTURE, EUROPEAN, BINARY flags are not available via broker API, they must be set by script.
  sInfo: the trading class symbol (if applicable)
• Variables or text set up with brokerCommand keep their content until modified by another brokerCommand. Take care of this when a previous trading session has used this command to set a variable or text.
• If the broker API provides no information about trades - as is the case for most NFA compliant APIs - make sure to keep the trades on the Zorro side and the broker side in sync. Don't close positions or cancel orders on one side only.
• If the broker API supports a particular order type, the plugin returns the ordertype on the SET_ORDERTYPE command; otherwise it returns 0.
• SET_ORDERTYPE >= 8 places a separate stop order when supported by the broker. Dependent on the behavior of the broker API, this order might stay alive even when the original trade was closed. In that case cancel it manually: Send a DO_CANCEL command with the stop order trade ID, which is normally the original trade ID +1. Otherwise the stop order might stay open and trigger an unwanted position in reverse direction.
• Not all price types are supported with all assets. Check with your broker which prices types are supported, and make sure to use SET_PRICETYPE only when available for the selected asset.Otherwise leave it at 0
S
• Some commands send a 32 bit pointer as parameter, for instance to pass a string or one or several double variables to the plugin. The broker plugin can then cast it to the required type for getting the content, f.i. double NewLotAmount = *(double*)Parameter;
• User defined commands for special broker API settings can be defined with a command number > 2000. Numbers below 2000 are reserved for predefined commands.

Examples:

brokerCommand(SET_COMMENT,strf("Algo %s",Algo)); // set a comment

brokerCommand(SET_PATCH,16+32); // take swap, commission, leverage from the asset list

var Greeks[5];
contractPrice(ThisContract);
brokerCommand(GET_GREEKS,Greeks); // get greeks of the current contract

// Read all positions from an asset list ///////////////////////
void main() 
{
  assetList("AssetsFix");
  string Name;
  while(Name = loop(Assets)) {
    var Position = brokerCommand(GET_POSITION,Name);
    printf("\n%6.4f %s",Position,Name);
    if(!wait(10)) break;
  }
}

// read and print the order book
void main() 
{
  static T2 Quotes[MAX_QUOTES];
  brokerCommand(SET_SYMBOL,"AAPL");
  int i,N = brokerCommand(GET_BOOK,Quotes);
  printf("\nOrderbook: %i quotes",N);
  for(i=0; i<N; i++)
    printf("\nPrice %.2f Vol %.2f",(var)Quotes[i].fVal,(var)Quotes[i].fVol);
}

// read JSON data string from the Coinigy REST API
void main() 
{
  brokerCommand(SET_BROKER,"GDAX");
  static char Buffer[MAX_BUFFER];
  strcpy(Buffer,"#data "); // target point
  strcat(Buffer,"{\n\"exchange_code\": \"GDAX\",");
  strcat(Buffer,"\n\"exchange_market\": \"BTC/USD\",");
  strcat(Buffer,"\n\"type\": \"bids\"\n}");
  int Size = brokerCommand(GET_DATA,Buffer);
  if(Size)
    printf("\nResponse: %s",Buffer);
}

// Use Zorro HTTP functions in a REST API plugin
int (__cdecl *http_send)(const char* url,const char* data,const char* header) = NULL;
long (__cdecl *http_status)(int id) = NULL;
long (__cdecl *http_result)(int id,char* content,long size) = NULL;
int (__cdecl *http_free)(int id) = NULL;
...
DLLFUNC double BrokerCommand(int command,intptr_t parameter)
{
  switch(command) {
    case SET_FUNCTIONS: {
      FARPROC* Functions = (FARPROC*)parameter;
      (FARPROC&)http_send = Functions[139];
      (FARPROC&)http_status = Functions[142];
      (FARPROC&)http_result = Functions[143];
      (FARPROC&)http_free = Functions[144];
      return 1.;
    }
    ...
  }
  return 0.;
}

See also: