Bitcoin Forum

<?php
date_default_timezone_set('Europe/Berlin');

while(true)
{

	$pair = "WDC_BTC";
	$buyrice = 0.00001000;
	$buyAmount = 50;
	logging("/////////////////////////////");
	logging("BUY ORDER");
	$buyOrderID = buyOrder($pair, $buyrice, $buyAmount);
	var_dump($buyOrderID);
        // Change this parameter to find the sweet spot of the API response / caching time
	//sleep(15);
	
	logging("/////////////////////////////");
	logging("INFO ORDER");
	$info = statusOrder($buyOrderID["order_id"]);
	var_dump($info);
	
	logging("/////////////////////////////");
	logging("CANCEL ORDER");
	$cancel = cancelOrder($buyOrderID["order_id"]);
	var_dump($cancel);
	
	logging("/////////////////////////////");
	logging("FINISHED");
	logging("/////////////////////////////");
	sleep(20);


}









//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function query($path, array $req = array()) 
{
	$api_url = "https://bter.com/api/1/";
	$apiKey = "";
	$apiSecret = "";
	
	
	
	// Prevent API from overload
	usleep(300000);
	
	// generate a nonce to avoid problems with 32bits systems
	$mt = explode(' ', microtime());
	$req['nonce'] = $mt[1].substr($mt[0], 2, 6);
 
	// generate the POST data string
	$post_data = http_build_query($req, '', '&');
	$sign = hash_hmac('sha512', $post_data, $apiSecret);
 
	// generate the extra headers
	$headers = array(
		'KEY: ' . $apiKey,
		'SIGN: ' . $sign,
	);

	//!!! please set Content-Type to application/x-www-form-urlencoded if it's not the default value

	// curl handle (initialize if required)
	static $ch = null;
	if (is_null($ch)) {
		$ch = curl_init();
		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
		curl_setopt($ch, CURLOPT_USERAGENT, 
			'Mozilla/4.0 (compatible; Bter PHP bot; '.php_uname('a').'; PHP/'.phpversion().')'
			);
	}
	curl_setopt($ch, CURLOPT_URL, $api_url . $path);
	curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);
	curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
	curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);

	// run the query
	// run the query
	$error = null;
	for ($i = 0; $i < 5; $i++) 
	{
		try 
		{
			$res = curl_exec($ch);
		}
		catch (Exception $ex) 
		{
			$error = "[BTER] Private API CALL error: " . print_r($ex->getMessage(), true);
			logging($error, true);
			sleep(1);
			continue;
		}

		if ($res === false) 
		{
			$error = "[BTER] Could not get reply: " . curl_error($ch);
			logging($error);
			continue;
		}
		
		
		$dec = json_decode($res, true);
		//Debugging only
		// var_dump($dec);
	
		if (!$dec || $dec["result"] != "true" || (key_exists("msg", $dec) && $dec["msg"] != "Success"))
		{
			$error = "[BTER] Private API RESPONSE error: " . print_r($dec, true);
			$info = " Method: " . print_r($path, true) . " / Parameter: " . print_r($req, true);
			logging($error . "\n" . $info, true);
			sleep(5);
			continue;
		}
		else
			return $dec;
	}
}




function buyOrder($pair, $buyrice, $buyAmount)
{
	return query('private/placeorder', array
			(
				'pair' => strtolower($pair),
				'type' => 'buy',
				'rate' => $buyrice,
				'amount' => $buyAmount
			)
	);
}



function cancelOrder($orderID) 
{
	return query('private/cancelorder', array('order_id' => $orderID));
}



function statusOrder($orderID) 
{
	return query('private/getorder', array('order_id' => $orderID));
}



function logging($message) 
{
	echo date("H:i:s") . ": " . $message . "\n";
}

case class Decimals ( calc: DecSet,
                      show: DecSet,
                      trade: DecSet )

case class DecSet ( decRate: Int,
                    decBase: Int,
                    decCntr: Int,
                    fmtHRtA: String => String,
                    fmtHRtB: String => String) {

  import tradebot.div.tools._

  /* rounding */
  def rndRate(v: Double) = roundDouble(v, decRate)
  def rndBase(v: Double) = roundDouble(v, decBase)
  def rndCntr(v: Double) = roundDouble(v, decCntr)

  /* formatting */
  def fmtRate(v: Double) = format(v, decRate)
  def fmtBase(v: Double) = format(v, decBase)
  def fmtCntr(v: Double) = format(v, decCntr)


  /* highlight the four relevant decimals */
  def fmtHRate(v: Double) = { ... }
}

case class SDBasicTrade ( trdDirection: TTrdDir.TTrdDir,
                          amount: Double,
                          rate: Double) {

  def toStr(decs: DecSet, units: BCUnits) =
      List( TTrdDir.toStr(trdDirection).toUpperCase, decs.fmtBase(amount),
              units.b, "@", decs.fmtRate(rate)).mkString(" ")
}

   val trade = SDBasicTrade ( trdDirection = tdBuy,
                                           amount = 1,
                                           rate = 0.01 ) 

   println("executing trade -> " + trade.toStr(decs.trade, ... )
   logic.executeTrade(trade) 

/* base/counter currency pair class and its companion object */
object BCPair extends XMLTools {
  def apply(b: Double, c: Double) = new BCPair(b, c)
  def apply(bcp: BCPair) = new BCPair(bcp.b, bcp.c)
  def apply() = new BCPair()
  def apply(xml: Elem) = new BCPair( b = tDbl(xml \ "base"),
                                     c = tDbl(xml \ "counter"))
  val zero = BCPair(0, 0)
  val error = BCPair(-1, -1)
}

class BCPair (var b: Double = 0, var c: Double = 0) {

  /* data manipulation */
  def set(in: (Double, Double)) {b = in._1; c = in._2}
  def set(bcp: BCPair) {b = bcp.b; c = bcp.c}
  def set(bb: Double, cc: Double) {b = bb; c = cc}


  /* abs, rounding*/
  def abs = BCPair(scala.math.abs(b), scala.math.abs(c))
  def rnd(decs: DecSet) = BCPair( b = decs.rndBase(b),
                                  c = decs.rndCntr(c) )


  /* check conditions */
  def cndAND (f: Double => Boolean) = f(b) && f(c)
  def cndOR (f: Double => Boolean) = f(b) || f(c)


  /* standard operators */
  def + (that: BCPair) = new BCPair(this.b + that.b, this.c + that.c)
  def - (that: BCPair) = new BCPair(this.b - that.b, this.c - that.c)
  def * (d: Double) = new BCPair(this.b * d, this.c * d)
  def / (d: Double) = new BCPair(this.b / d, this.c / d)
  def isEqual (that: BCPair) = this.b == that.b && this.c == that.c

  /* calc the rate: i * r = c  <=> r = c / i */
  def calcRate = if (b != 0) scala.math.abs(c / b) else -1D


  /* delivers min/max values of both entries */
  def mergeMax(that: BCPair) = BCPair( b = tools.max(b, that.b),
                                       c = tools.max(c, that.c) )

  def mergeMinPos(that: BCPair) = {
    def oz(x: Double, y: Double) = (x > 0, y > 0) match {
      case (true, true) => tools.min(x, y)
      case (false, true) => y
      case (true, false) => x
      case (false, false) => 0D }
    BCPair(b = oz(b, that.b), c = oz(c, that.c)) }


  /* formatted output */
  def print = "base:" + b + " cntr:" + c

  def toStr( bcu: BCUnits, decB: Int, decC: Int) =
      fmtAmt(b, bcu.b, decB) + " | " + fmtAmt(c, bcu.c, decC)

  def toStr( bcu: BCUnits, fmtB: Double => String, fmtC: Double => String) =
      fmtAmt(b, bcu.b, fmtB) + " | " + fmtAmt(c, bcu.c, fmtC)

  def toStr(decs: Decimals, units: BCUnits): String =
      toStr(bcu = units, decB = decs.decBase, decC = decs.decCntr)

  def toStr(decs: DecSet, units: BCUnits): String =
      toStr(bcu = units, decB = decs.decBase, decC = decs.decCntr)


  /* XML output */
  def toXML = fXML(b.toString, c.toString)
  def toXML(decs: DecSet) = fXML(decs.fmtBase(b), decs.fmtCntr(c))
  private def fXML(sb: String, sc: String) =
              <bcpair><base>{sb}</base><counter>{sc}</counter></bcpair>


  /* helper functions */
  private def cLen(s: String) = {if (s.indexOf("-") < 0) 1 else 0} + s.length

  private def fmtAmt(v: Double, unit: String, fmt: Double => String) = {
    val s = fmt(v)
    tools.pst( cLen(s), s) + " " + unit }

  private def fmtAmt(v: Double, unit: String, dec: Int) = {
    val s = tools.format(v, dec)
    tools.pst( cLen(s), s) + " " + unit }
}

  // ... hiermit beispielsweise zwei Handelergebnisse aufsummieren.
  val a = BCPair(b = 1, c = 100)
  val b = BCPair(2, -30)
  val c = a + b // wäre hier BCPair(3, 70)

  // und mit der toStr-Methode ins Logfile schreiben
  log.trade("trade result -> " + c.toStr(decs.calc, ...)

  // oder testen, ob beide werte positiv sind
  if (c.cndAND (v => v > 0)) { ... }

/* the IFExTradeData class itself */
case class IFExTradeData ( dbid: Int,
                           typ: TTrdDir.TTrdDir,
                           bcu: BCUnits,
                           timestamp: Long,
                           tradeid: Long,
                           orderid: Long,
                           resultWOF: BCPair,
                           resultWF: BCPair,
                           fees: BCPair,
                           rateWOF: Double,
                           rateWF: Double)  extends IFExDataBase(dbid) {

  /* for error messages */
  override val errorClassName = "IFExTradeData"

  /* check on equality */
  def isEqual(that: IFExTradeData) = dbid == that.dbid &&
                                     typ == that.typ &&
                                     bcu == that.bcu &&
                                     timestamp == that.timestamp &&
                                     tradeid == that.tradeid &&
                                     orderid == that.orderid &&
                                     resultWOF.isEqual(that.resultWOF) &&
                                     resultWF.isEqual(that.resultWF) &&
                                     fees.isEqual(that.fees) &&
                                     rateWOF == that.rateWOF &&
                                     rateWF == that.rateWF

  /* type to string */
  def typStr = TTrdDir.toStr(typ)

  /* delivers a copy with setting of a changed database id */
  def copyWithDBID(id: Int) = copy(dbid = id)

  /* build log string */
  def toLog( indent: String, decs: DecSet) = {

    def strBCP(bcp: BCPair) =
      bcp.toStr( bcu, decs.fmtBase _, decs.fmtCntr _)

    List( "TRADEDATA",
          indent + "typ          :   " + typStr.toUpperCase,
          indent + "orderid      :   " + orderid,
          indent + "tradeid      :   " + tradeid,
          indent + "timestamp    :   " + tools.dateToString(timestamp),
          indent + "res w/o fee  :  " + strBCP(resultWOF),
          indent + "res w fee    :  " + strBCP(resultWF),
          indent + "fees         :  " + strBCP(fees),
          indent + "rate w/o fee : " + fmtValue(rateWOF, decs.fmtRate),
          indent + "rate w fee   : " + fmtValue(rateWF, decs.fmtRate)).mkString("\n") }




  /* creates a name/value map for database storing */
  override def dbValues(tableName: String, secID: Int) =
    Map( ("TableName", tableName),
         ("PrimaryKeyName", pkName),
         ("PrimaryKeyValue", dbid),
         ("secid", secID),
         ("typ", typStr),
         ("base", bcu.b),
         ("cntr", bcu.c),
         ("timestamp", timestamp),
         ("tradeid", tradeid),
         ("orderid", orderid),
         ("ratewof", rateWOF),
         ("ratewf", rateWF)) ++
         mapBCP("resultwof", resultWOF) ++
         mapBCP("resultwf", resultWF) ++
         mapBCP("fees", fees)

  /* stores to database, only if not exists */
  override def store(db: Database, table: String, secID: Int) =

    /* checks if dataset already exists */
    db.selectFromDB( table, "where tradeid=" + tradeid, "") match {

      /* dataset retrieved --> no action */
      case rs: ResultSet if rs.next() => rs.close()

      /* no dataset found --> store */
      case rs: ResultSet => super.store(db, table, secID); rs.close()
      case _ => super.store(db, table, secID) }


}