Re: BTC-E + GOX Роллинг бот, качалка бот, торговый бот, Full-Code
Это будет считаться не рабочий код. Есть по крайней мере, 8 торговых двигателей некоторые полные и некоторые нет. Есть также несколько сотен настраиваемых параметров. Я ни в коей мере предлагая поддержку, помощь или подразумевая, или с указанием каких-либо гарантий для этого. Jude использует двигатель в течение некоторого времени, и я считаю, что делает небольшую прибыль. Я использовал различные двигатели и переписываю торговать на микро и макро рулонов рулонов с разной степенью успеха.
Я оставил много нот, как это код мастер-файл с большим количеством незаконченных произведений.
Если я забыл удалить какую-либо личную информацию или ключи, я был бы признателен PM против расходного хака.
Наиболее важные параметры обмена, btcekey btcesecret и вниз к основанию клавишу GOX и секрет. Существует синтезированная функция, которая будет просто распечатать вывод и не должен выполнять какую-либо сделки.
Если вы не можете выяснить, что делает этот код: только предположить, что это крадет все ваши Bitcoins.
Функция EMA потребуется несколько изменений цен, чтобы начать торговать, так как он должен построить таблицу EMA и не помнит его после того, как программа будет остановлена.
Кроме того: сообщение превышает максимально допустимую длину (64000 символов).
Так что в двух постах.
Код:
<до>
////////////////////////////////////////////////// //////////////////
// Программы
////////////////////////////////////////////////// //////////////////
// A - Валюта Арбитраж, выберите UtoU или BtoB арбитраж через L
// B - Портфолио Балансировка, Поддержание 50% двух валют во все времена
// C - Пользовательский трейлинг / опережения продать / продам бот для GNA
// D - купить вниз, купить 1/2 спреда каждый .5 падение и продавать 1 каждый $ 1 выигрыш
// E - Прокатное продать / продать на спадах и шипы V1,1.1,1.2, V2,2.1
// F - 24 часов высокие / низкие балансировка боты, поддерживать (высокие последний) / (высокий-низкий) баланс в долларах США и (последний низкий) / (высокий-низкий) в BTC
// G - EMA вызвало прокатке с долей Фибоначчи и высокой / низкой комбинации балансировки с микро-торговли повторной балансировки.
// H - Пользовательский Роллинг боты на основе динамических порогов
// I - Micro-Trade качению бота с переменной покупки и продажи заказов и итераций
// J - Revamped микро-перебалансировка двигатель добавлен в качестве опции - баланс в зависимости от расстояния до высокой цены
////////////////////////////////////////////////// //////////////////
// Advance и хвост последняя цена с заказами (комиссионный + прибыль / 2)
// Установить порядок составляет мин < все < Максимум
// Покупать цена падает
// Sell, как рост цен
// использование тройной EMA + последняя для определения тенденций
// USE расстояние от высокой / низкой, чтобы определить средства, чтобы продать / купить
// ПРИМЕЧАНИЕ Купить в последнем - пороговое значение (сумма мин (maxtrade, восстановить баланс в процентах)
// заказы NUM ПРИМЕЧАНИЕ устанавливается для покупки и продажи, использование $ incriment разницы заказа
// Примечание 100 заказов продать будет price1 + +0,01 + +0,01 и т.д.
// Не продавать, если последний > EMA1 > EMA2 > EMA3
// Не покупать, если последний < EMA1 < EMA2 < EMA3
// Использование микро-заказы, чтобы играть на пиках и спадах
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// USER КОНФИГУРИРУЕМЫЙ
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
//ФУНКЦИИ
$ DEBUG = TRUE; // Если программа для печати информации отладки
$ Симулировать = FALSE; // Запускается в режиме моделирования, НЕТ ТОРГИ НЕ СДЕЛАНЫ только ПЕЧАТЬ ВЫХОД
$ Обмен = "G"; // Выбор обмена для запуска на
если ($ обмен == "G") {$ GOX = TRUE; $ = FALSE, BTC-E;}
если ($ обмен == "Е") {$ = TRUE, BTC-E; $ GOX = false;}
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Выбор ENGINE
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ ENGINE = "M";
// H - Hybrid Engine
// E - EMA двигатель
// S - статический двигатель
// B - Заполненный двигателя
// FF - 50/50 Баланс двигателя
// JOSH - Джош Торговой система
// JUDE - Джуд Торговая система
// M - Micro-ролл двигатель
// F
$ ГИБРИД = $ СТАТИЧЕСКОЕ = $ ЕМА = $ БАЛАНС = $ ДЖОШ = $ FF = $ F = FALSE;
Переключатель ($ ДВИГАТЕЛЬ) {
случай "H":
$ HYBRID = TRUE;
ломать;
случай "E":
$ EMA = TRUE;
// EMA раз использовать
$ Ema1Time = 5;
$ Ema2Time = 11;
$ Ema3Time = 22;
$ Ema1M = 2 / ($ ema1Time + 1);
$ Ema2M = 2 / ($ ema2Time + 1);
$ Ema3M = 2 / ($ ema3Time + 1);
ломать;
случай "S":
$ STATIC = TRUE;
ломать;
случай "M":
$ MICRO = TRUE;
////////////////////////////////////////////////// //////////////////
// НАСТРОЙКИ MICRO-ТРЕЙД
//array(0.023360861,0.035041292,0.040881508,0.055482046,0.06862253,0.089793311,0.113519186,0.146552904,0.186795638,0.239950723); //0,1,1.5,N1+N2/2,N2+N3/2 ... Modified Фибоначчи делится на 10 раундов.
/ *
Метод выдумка - вычисляет Фибоначчи акций
1,2,3,5,8,13 мультипликатором X = 1 / (сумма всех чисел) * {X} серии
Метод выдумка ручной - вычисляют Фибоначчи акции с делителем для n3 +.
$ MicroBuyAmountMultiplier = engineMultiplier ( 'fibtame', 4, $ microBuyDivisor);
n1 = 1, n2 = n1 + n1 / х, n3 = n1 + n2 / х, и т.д..
Метод пау - экспоненциальный рост путем итерации
2 ^ х, 2 ^ х + 1
Метод случайного - вычисляет случайные числа
Метод двойного - удваивает количество каждого заказа
1,2,4,8,16
Метод сов - делает дугу, используя итерацию и соз
Метод экос - делает обратную дугу, используя итерацию и АСОсы
здесь способ дуги, начните .5 двигаться до 1 двигаться вниз к .5 движению вверх для остатка
4 балла, 1 половина, 2 полно, 3 составляет половину, 4 является последним, который должен быть ручным,
* /
$ MicroSellDivisor = 10; // количество ордеров на продажу на место
$ MicroBuyDivisor = 10; // Количество заказов на покупку, чтобы разместить
$ MicroIteration = 0,5; // USD $ итерации для нескольких заказов
$ MicroAmount = +0,01; // Количество BTC в мини купить / продать тур
$ MicroProfit = +0,005; // Порог прибыли, это минимальная прибыль на сделку, чтобы сделать,
$ MicroStopLoss = 1; // Стоп-лосс процентов, продать в убыток
$ MicroReBuy = 0,10; // Изменение цены на ребай после потери
$ MicroBuyAmountMultiplier = engineMultiplier ( 'двойной', 2, $ microBuyDivisor);
если ($ GOX) {
$ MicroSellDivisor = 10; // количество ордеров на продажу на место
$ MicroBuyDivisor = 10; // Количество заказов на покупку, чтобы разместить
$ MicroIteration = 0,5; // USD $ итерации для нескольких заказов
$ MicroAmount = +0,01; // Количество BTC в мини купить / продать тур
$ MicroProfit = 0,004; // Порог прибыли, это минимальная прибыль на сделку, чтобы сделать,
$ MicroStopLoss = 1; // Стоп-лосс процентов, продать в убыток
$ MicroReBuy = 0,1; // Изменение цены на ребай после потери
$ MicroBuyAmountMultiplier = engineMultiplier ( 'Rand', 2, $ microBuyDivisor);
}
$ MicroSellCancel = TRUE; // Отменить заказы каждый продавать или хранить старые заявки на продажу?
////////////////////////////////////////////////// //////////////////
// НЕ USER КОНФИГУРИРУЕМЫЙ
$ EngineProfit = $ microProfit;
$ EngineAmount = $ microAmount;
$ EngineSellDivisor = $ microSellDivisor;
$ EngineBuyDivisor = $ microBuyDivisor;
$ CountMicroBuy = $ countMicroSell = 1;
$ CountMicroBuyTotal = $ countMicroSellTotal = 0;
$ MicroBuy = $ microSell = FALSE;
$ MicroThreshold = 0,60; // динамический порог определяется произвольно.
$ MicroTicker = 0; // Хранит последнюю цену, используемую для расчета мини-сделок
ломать;
случай "B":
$ BALANCE = TRUE;
$ BalanceBuy = $ balanceSell = FALSE;
$ BalanceAmount = 0,025; // Количество микро-балансовых торгов
$ BalanceThreshold = +0,05; // .05 = 5% // Перебалансирование leway - значение 1, чтобы отключить
ломать;
случай "FF":
$ BALANCE = TRUE;
$ FF = TRUE;
ломать;
случай "JOSH":
$ JOSH = TRUE;
$ JoshAmount = 5; // В BTC
$ JoshThreshold = 5; // В USD
$ JoshStopLoss = +0,05; // в процентах
$ JoshReBuy = +0,05; // в процентах
ломать;
случай "JUDE":
$ JUDE = TRUE;
ломать;
}
//Остановить потери
$ = Остановки массива ( 'цель', 'бегущей строки', 'над', 'под', 'количество' => 0);
// Максимальное количество игры (это играть не инвестиции), это все-таки технически бета-идея
$ MaxUSD = 500; // Максимальное количество долларов США для использования -> включает в себя B * провел последнюю цену!
$ MaxBTC = 1; // Максимальное количество BTC использовать
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Настройки Основного двигателя торговли
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ AmountTrade = 0,256; // maxpertrade ток двигателя 20130530
$ SellDivisor = 3; // Количество ордеров на продажу на место
$ BuyDivisor = 3; // Количество ордеров на покупку на месте
$ TradeIteration = 0,10; // Если не использовать сложные проценты, сумма различаются между сделками при использовании продать / купить делитель выше 1
$ CompoundInterest = FALSE; // Использование $ incriment или прибыль ^ (1 + х)
$ Порог = 0,60; // Пороговое изменение цены НЕИСПОЛЬЗУЕМЫЙ как это установлено позже.
$ ProfitTrade = 0,025; // Порог прибыли, это минимальная прибыль на сделку, чтобы сделать,
$ ThresholdOrders = 0; // При использовании триггеров порядка на основе против статического или EMA
$ MaxPendingOrders = 0; // Держите это много заказов активным при отмене
$ MaxOrders = 100; // $ maxOrders = макс заказы тянуть должны быть установлены? 100?
// Отправка отчетов по электронной почте при размещении заказов
$ EmailRCPTo = "SET IN KEY.PHP инклюдник";
$ BtceKey = ''; // ваш API-ключ
$ BtceSecret = ''; // Ваш Секретный ключ
$ = Почтовое сообщение "BTCbot торговля на {$ обмена}";
// Время между запусками
$ Nanosleep = 500000000; // наносекунд
$ SleepCancel = +500000; // наносекунд спать между отмен заказов
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// END USER КОНФИГУРИРУЕМЫЙ
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ MinBidBTC = +0,01; // Минимальных Заявок обмена будет принимать (BTC-E Mins)
$ EngineAmount = (мин ($ microAmount / $ microSellDivisor, $ microAmount / $ microBuyDivisor) > $ MinBidBTC? $ MicroAmount: $ minBidBTC);
// DEBUG нужно добавить множитель массив низкого до этого
если ($ обмена == "E") $ exchangeCommision = .002; // Обмен комиссионный процент (в 1 - комисся в десятичной системе)
если ($ обменной == "G") $ exchangeCommision = .0001; // GOx Commision
// BTC-E Валютные пары & ставка задать имена в формате JSON
$ Btcesymbol = массив ( "btc_usd", "ltc_btc", "ltc_usd");
$ Btcebidorask = массив ( "торги", "спрашивает");
если (@ $ BTC-E) $ exchangeBuySell = массив ( "купить", "продать");
если (@ $ GOX) $ exchangeBuySell = массив ( "ставка", "спросить");
$ ExecuteTrade = $ postTrade = FALSE;
$ ПРОДАМ = $ BUY = TRUE;
$ DOT = $ STOPLOSS = FALSE; // довольно выход \ п BOOL
// СЧЕТЧИКИ
$ CountIteration = 1; // Итерация Счетчик
$ CountOrder = 0; // счетчик заказа
$ CountError = 0; // Счетчик ошибок
$ CountDuplicate = 0; // Дубликат последняя цена счетчика
$ CountBuys = $ countSells = 0; // Счетчик скорость покупки / incriments на скорости покупки, так что это не количество ордеров на покупку, но количество ставок купить пытался
$ CountTrades = 0; // счетчик выполнения торговли
$ CountTickers = 0;
$ Ь = $ s = 0;
$ CountInValid = $ countValid = 0;
$ CountCancelled = $ countFilledBuy = $ countFilledSell = $ countFilled = $ countFilledIterationBuy = $ countFilledIterationSell = 0;
// Тикеры
$ Тикер = $ tickerLast = $ тикеров = массив ();
// получить incriment из нашего файла
$ Nonce = readInc (); // + 1;
// порядок отмены таймера
$ = Время начальный промежуток ();
$ DateStart = Дата ( 'Ymd Н: я: s');
////////////////////////////////////////////////// //////////////////
// Вычислить $ microBuyAmountMultiplier $ engineMultiplier
////////////////////////////////////////////////// //////////////////
функционировать engineMultiplier ($ метода = NULL, $ итерации = NULL, $ делитель = NULL)
{
Переключатель ($ метод)
{
дело «рэнд»:
для ($ = 1; $ я<= $ Делитель; $ я ++) {
$ Массив [$ я] = Rand (1, $ итерации);
}
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
случай «приврать»:
$ Первый = 1; $ Второй = 2;
$ Массив [0] = $ первый;
$ Массив [1] = $ второй;
для ($ I = 2; $ я<= $ Делителя + 1; $ я ++) {
$ = $ Конечного первый + второй $;
$ Первый = $ второй;
$ Второй = $ окончательным;
$ Массив [$ я] = $ окончательным;
}
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
случай "fibtame":
$ Первый = 1; $ = $ Второй первый + $ первый / $ итерации;
$ Массив [0] = $ первый;
$ Массив [1] = $ второй;
для ($ I = 2; $ я<= $ Делителя + 1; $ я ++) {
$ = $ Конечные первый + $ второй / $ итерации;
$ Первый = $ второй;
$ Второй = $ окончательным;
$ Массив [$ я] = $ окончательным;
}
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
случай «ехр»:
$ Массив [1] = 1;
$ Массив [2] = 2;
для ($ I = 3; $ я<= $ Делитель; $ я ++) {
$ Массив [$ я] = пау ($ я, $ итерации);
}
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
случай «двойной»:
$ Массив [0] = 1;
$ Массив [1] = 2;
для ($ I = 2; $ я<= $ Делитель; $ я ++) {
$ Массив [$ я] = $ массив [$ я-1] * 2;
}
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
случай «сов»:
// DEBUG затруднительное так массив 0 существует.
$ Массив [1] = -1,5;
// print_r ($ массив);
для ($ I = 3; $ я<= $ Делителя + 1; $ я ++) {
$ Массив [$ I-1] = ABS (COS ($ массив [1] + ((3 / ($ делителем-1)) * ($ 2-я))));
}
$ Массив [1] = ABS (COS (-1.5));
// print_r ($ массив);
$ Возврата = engineMultiplierPercentage ($ массив);
ломать;
}
вернуть $ вернуться;
}
Функция engineMultiplierPercentage ($ массив)
{
$ Процентах = 1 / array_sum ($ массив);
Еогеасп ($ массив в $ ключ => $ Значение)
{
$ Возврата [$ ключ] = значение $ * $ процент;
}
вернуть $ вернуться;
}
////////////////////////////////////////////////// ////////////////////////////////////////////////// ////////////////////////////////////
////////////////////////////////////////////////// ////////////////////////////////////////////////// ////////////////////////////////////
//////////////////////////////////////////////// Begin Infinite Loop.//////////////////////////////////////////////// ////////////////////
////////////////////////////////////////////////// ////////////////////////////////////////////////// ////////////////////////////////////
////////////////////////////////////////////////// ////////////////////////////////////////////////// ////////////////////////////////////
в то время как ( «ответ на жизнь вселенная и все»! = «41») {
//include('key.php ');
writeInc ($ нонс); // Записывает нонс переменного
$ CountIteration ++; // incriment счетчик итераций
$ CountDuplicate = $ countOrder = $ countError = 0; // Новый запуск сброса счетчика дублированный
$ ExecuteTrade = FALSE; // сброс торговли BOOL для следующего запуска
$ Возврата = $ Orderlist = $ TradeHistory = $ скорость = $ сумма = $ = тип массив (); // удалить предыдущие значения из торговых массивов
////////////////////////////////////////////////// //////////////////
// данные опроса
////////////////////////////////////////////////// //////////////////
$ TickerOld [ 'тикер'] [ 'последний'] = @ $ тикер [ 'тикер'] [ 'последний']; // изменяет тикер к последнему тикеру
$ Тикер = массив ();
$ Сна = Rand (1, 10); // установить таймер случайного сна
в то время как (пусто ($ тикер)) {
если (@ $ GOX) {
$ Тикер = json_decode (отправить ( 'https://data.mtgox.com/api/2/BTCUSD/money/ticker'), TRUE);
$ Тиккера [ 'тиккера'] [ 'последняя'] = $ тиккера [ 'данные'] [ 'последняя'] [ 'значение'];
}
если (@ $ BTC-E) $ тикер = json_decode (отправить ( 'https://btc-e.com/api/2/btc_usd/ticker'), TRUE);
если (! @ $ тикер) {
print_r ($ возврата);
$ Тикер = $ возврата = $ OrderList = $ TradeHistory = массив ();
// $ сон = рандов (6, 36) * (++ $ countError);
$ CountError ++;
печать "\ nНомер ошибки потянув данных Error #: {$ countError} \ п.";
сна (5);
Продолжать;
}
////////////////////////////////////////////////// //////////////////
// Дубликат Ticker
если ($ tickerOld [ 'тикер'] [ 'последний'] == $ тикер [ 'тикер'] [ 'последний']) {
$ Тикер = $ возврата = $ OrderList = $ TradeHistory = массив ();
если ($ countDuplicate == 59 печати "\ п.": "" печать);
если ($ countDuplicate == 59 $ countDuplicate = 0: NULL);
$ DOT = TRUE;
$ CountDuplicate ++;
// Статический таймер
time_nanosleep (0, $ nanosleep);
Продолжать;
}
////////////////////////////////////////////////// //////////////////
// Вычислить SMA & EMA
если ($ тикер [ 'тикер'] [ 'последний'] > 0 && $ TickerOld [ 'тикер'] [ 'последний']! == $ тикер [ 'тикер'] [ 'последний'] && $ EMA) {// позже тест дублировать тикер никогда не должен быть проверен.
$ countTickers ++;
$ тиккеры [$ countTickers] = $ тикер [ 'тикер'] [ 'последний'];
$ EMA1 = $ ema2 = $ EMA3 = NULL; // = $ countTickers
$ EMA1 = array_sum (array_slice ($ бегущие строки, -1, 1, TRUE)) * $ ema1M + (array_sum (array_slice ($ тикеры, ($ ema1Time * -1) -1, $ ema1Time, правда)) / $ ema1Time) * (1- $ ema1M);
$ Ema2 = array_sum (array_slice ($ бегущие строки, -1, 1, TRUE)) * $ ema2M + (array_sum (array_slice ($ тикеры, ($ ema2Time * -1) -1, $ ema2Time, правда)) / $ ema2Time) * (1- $ ema2M);
$ EMA3 = array_sum (array_slice ($ бегущие строки, -1, 1, TRUE)) * $ ema3M + (array_sum (array_slice ($ тикеры, ($ ema3Time * -1) -1, $ ema3Time, правда)) / $ ema3Time) * (1- $ ema3M);
если ($ countTickers < $ Ema1Time + 1) {//&& $ EMA) {
если (@ $ DEBUG && $ DOT) {печать "\ п"; $ DOT = FALSE; }
печать «Строительство EMA1 - Ожидание»;
печать ($ ema1Time + 1) - $ countTickers;
печать «больше тиккеров \ п»;
} ELSEIF ($ countTickers < $ Ema2Time + 1) {//&& $ EMA) {
если (@ $ DEBUG && $ DOT) {печать "\ п"; $ DOT = FALSE; }
печать «Строительство EMA2 - Ожидание»;
печать ($ ema2Time + 1) - $ countTickers;
печать «больше тиккеров \ п»;
} ELSEIF ($ countTickers < $ Ema3Time + 1) {//&& $ EMA) {
если (@ $ DEBUG && $ DOT) {печать "\ п"; $ DOT = FALSE; }
печать «Строительство EMA3 - Ожидание»;
печать ($ ema3Time + 1) - $ countTickers;
печать «больше тиккеров \ п»;
}
если ($ countTickers < $ Ema3Time + 1) {// Если мы не построили EMA3, и мы используем ЕМА
$ TickerOld [ 'тикер'] [ 'последний'] = $ тикер [ 'тикер'] [ 'последний'];
$ Тикер = $ возврата = $ OrderList = $ TradeHistory = массив ();
Продолжать; // перезапустить цикл, пока мы не строить EMAS
}
// Если мы не будем выполнять торговлю, распечатайте тикер, а затем продолжить
//если (
// ($ тикер [ 'тикер'] [ 'последний'] >= $ MicroTicker - $ microThreshold && $ Тикер [ 'тикер'] [ 'последний'] <= $ MicroTicker + $ microThreshold) // Мы не будем выполнять microtrade
//&& ($ EMA! (($ EMA1 > $ ema2 && $ ema2 > $ EMA3) && $ ПРОДАВАТЬ) // Мы не будем покупать
// && (($ EMA1 < $ ema2 && $ ema2 < $ EMA3) && $ ПРОДАВАТЬ) // Мы не будем продавать
//) // END EMA
// || ($ BALANCE
// && $ CurrentBalanceUSD- $ reBalanceUSD > 0
// && $ CurrentBalanceBTC- $ reBalanceBTC > 0)
//) // END БАЛАНС
//
// && $ TickerOld [ 'тикер'] [ 'последний']! == $ тикер [ 'тикер'] [ 'последний'] // Тикер не DUP (никогда не должны быть проверены здесь)
// && $ Тикер [ 'тикер'] [ 'последний'] > 0 // Тикер правомочно (никогда не должен быть протестирован здесь)
// && $ countIteration > 2) {// Это допустимая итерация
// $ TMP4 = круглый ($ тикер [ 'тикер'] [ 'последний'], 2); // круглый тикер
// если ($ countDuplicate >= 59-6) {
// для ($ countDuplicate = $ countDuplicate; $ countDuplicate < 59; $ CountDuplicate ++) {
// Распечатать ".";
//}
// печать "\ п";
// $ countDuplicate = 0;
//}
// печать "{$ TMP4}";
// $ countDuplicate = $ countDuplicate + 6;
// $ tickerOld [ 'тикер'] [ 'последний'] = $ тикер [ 'тикер'] [ 'последний'];
// $ тикер = $ возврата = $ OrderList = $ TradeHistory = массив ();
// $ tmp1 = $ tmp2 = $ tmp3 = $ TMP4 = NULL;
//}
} // ПОДРАЗУМЕВАЕМЫХ ELSE продолжить обработку
} // END в то время как (пусто ($ тикер))
////////////////////////////////////////////////// //////////////////
// Опрос Все данные для торговли
// сброс точек данных и тянуть все сразу (GOX должно быть исключением из ограничения скорости.)
$ Тикер = $ возврата = $ OrderList = $ TradeHistory = массив (); // поле пустым тиккеры
в то время как (пусто ($ тикер) || пустой ($ возврата) || пустой ($ OrderList) || пустой ($ TradeHistory)) {
если ($ BTC-E) {
$ Тикер = json_decode (отправить ( 'https://btc-e.com/api/2/btc_usd/ticker'), TRUE); // Код BTC-E
$ Orderlist = json_decode (btce_query ( "OrderList", массив ( "активный" => 1, "пара" => "Btc_usd")), TRUE);
$ TradeHistory = json_decode (btce_query ( "TradeHistory", массив ( "подсчет" => $ maxOrders, "пара" => "Btc_usd")), TRUE);
$ Возврата = json_decode (btce_query ( 'GetInfo'), TRUE); // Информация счета BTC-E
}
если ($ GOX) {
$ Тикер = json_decode (отправить ( 'https://data.mtgox.com/api/2/BTCUSD/money/ticker'), TRUE); // GOX Ticker
$ Тиккера [ 'тиккера'] [ 'последняя'] = $ тиккера [ 'данные'] [ 'последняя'] [ 'значение'];
$ Тикер [ 'тикер'] [ 'купить'] = $ тикер [ 'данные'] [ 'купить'] [ 'значение'];
$ Тикер [ 'тикер'] [ 'продать'] = $ тикер [ 'данные'] [ 'продать'] [ 'значение'];
$ Тиккера [ 'тиккера'] [ 'высокий'] = $ тиккера [ 'данные'] [ 'высокий'] [ 'значение'];
$ Тиккера [ 'тиккера'] [ 'низкий'] = $ тиккера [ 'данные'] [ 'низкий'] [ 'значение'];
$ Возврата = json_decode (mtgox_query ( 'BTCUSD / деньги / информация'), TRUE); // GOX счета информация
(? $ Возврата [ 'результат'] == "успех" $ возвращение [ 'успех'] = 1: $ возвращение [ 'успех'] = 0); // Переводим GOX для BTC-E
$ Возврата [ 'возврата'] [ 'средства'] [ 'BTC'] = $ возврата [ 'данных'] [ 'Кошельки'] [ 'BTC'] [ 'Баланс'] [ 'значение']; // Переводим GOX к BTC-E
$ Возврата [ 'возврата'] [ 'деньги'] [ 'USD'] = $ вернуть [ 'данные'] [ 'Кошельки'] [ 'USD'] [ 'Баланс'] [ 'значение']; // Переводим GOX к BTC-E
$ OrderList = json_decode (mtgox_query ( 'BTCUSD / деньги / заказы'), TRUE);
$ TradeHistory = json_decode (mtgox_query ( 'BTCUSD / деньги / сделки / загрузить'), TRUE); // GOX счета информация
$ TradeHistory [ 'возвращение'] = $ TradeHistory [ 'данные'];
снята с охраны ($ TradeHistory [ 'данные']);
Еогеасп ($ TradeHistory [ 'возвращение'], как $ ключ => $ Значение) {
$ TradeHistory [ 'возвращение'] [$ ключ] [ 'типа'] = $ TradeHistory [ 'возвращение'] [$ ключ] [ 'trade_type'];
$ TradeHistory [ 'возвращение'] [$ ключ] [ 'скорость'] = $ TradeHistory [ 'возвращение'] [$ ключ] [ 'цена'];
$ TradeHistory [ 'возвращение'] [$ ключ] [ 'Order_ID'] = $ ключ; // PHP Примечание:
}
}
// Проверяем тикер изменен
если (! @ $ тикер ||! @ $ возврат ||! @ $ OrderList ||! @ $ TradeHistory || @ $ вернуться [ 'успех']! == 1) {
print_r ($ возврата);
$ Тикер = $ возврата = $ OrderList = $ TradeHistory = массив ();
// $ сон = рандов (6, 36) * (++ $ countError);
$ CountError ++;
печать "\ nНомер ошибки потянув данных Error #: {$ countError} \ п.";
сна (5);
}
}
// Переводит данные GOx в BTC-й Формат
если (@ $ GOX) {
$ OrderList [ 'успех'] = ($ OrderList [ 'результат'] == "успех" $ OrderList [ 'успех'] = 1: $ OrderList [ 'успех'] = 0);
$ OrderList [ 'возвращение'] = массив ();
$ OrderList [ 'возвращение'] = $ OrderList [ 'данные'];
$ OrderList [ 'данные'] = NULL;
}
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Пороги установки для сбрасывая сделок
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
если ($ тикер [ 'тикер'] [ 'последний'] > 1) {// если тикер действует
если (@ $ GOX) {
если ($ возврата [ 'данные'] [ 'Trade_Fee'] > 0) $ exchangeCommision = $ возврата [ 'данные'] [ 'Trade_Fee'] / 100; // GOx Commision
}
$ Порог = CEIL ($ тиккера [ 'тиккера'] [ 'последняя'] * ((1 / (1- $ exchangeCommision) / (1- $ profitTrade / 2)) -1) * 100) / 100;
$ MicroThreshold = CEIL ($ тиккера [ 'тиккера'] [ 'последняя'] * ((1 / (1- $ exchangeCommision) / (1- $ microProfit / 2)) -1) * 100) / 100;
если (! @ $ microTicker || @ $ microTicker < 1) {
$ MicroTicker = $ тикер [ 'тикер'] [ 'последний'];
$ MicroThresholdBuy = $ microTicker + $ microThreshold; // Купить Над Последний создать отставая покупает - Micro-Dip
$ MicroThresholdSell = $ microTicker - $ microThreshold; // Продажа ниже прошлого, чтобы создать опережение продает - Micro-Spike
}
если (! @ $ thresholdBuy || @ $ thresholdBuy < 1) $ thresholdBuy = $ тиккера [ 'тиккера'] [ 'последняя'] + $ порога; // Мы устанавливаем заявки на покупку, когда цена увеличивается (задний покупка)
если (! @ $ thresholdSell || @ $ thresholdSell < 1) $ thresholdSell = $ тиккера [ 'тиккера'] [ 'последняя'] - $ порога; // Мы устанавливаем ордера на продажу, когда цена снижается (опережения продать)
} Еще {выход; }
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Расчет стоимости, балансы и резюме печати информации.
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// необходимо DEBUG для расчета стоимости в итерациях $ sellDivisor для сумм, которые будут торговаться.
// DEBUG СПРАВОЧНЫЕ НАПОЛНЕННЫЕ ЗАКАЗЫ! Предотвратить расчета стоимости на основе заполненных заявок на продажу!
$ BTCO = $ USDO = 0;
$ SellOrders = $ buyOrders = массив (); // пустой книги заявок для каждого нового запуска (Infinite Loop выпуск)
$ Ь = $ s = 0; // FIXED очистка заказа, если нет открытых заказов
если ($ OrderList [ 'успех'] > 0) {
Еогеасп ($ OrderList [ 'возвращение'], как $ ключ => $ Значение) {
если (@ $ GOX) {
$ Tmp1 = $ значение [ 'сумма'] [ 'значение'];
$ Значение [ 'сумма'] = NULL;
$ Значение [ 'сумма'] = $ tmp1;
$ Значение [ 'скорость'] = $ значение [ 'цена'] [ 'значение'];
$ Tmp1 = NULL; $ Tmp1 = $ значение [ 'сумма'] * $ значение [ 'скорости'];
$ Tmp1 = NULL;
}
если ($ значения [ 'типа'] == $ exchangeBuySell [1]) {
$ BTCO = $ BTCO + $ значение [ 'сумма']; // BTC = сумма заявок на продажу и суммы // PHP Фатальная ошибка: неподдерживаемые типы операндов в /arbot/buydownbotBTCG.php в строке 281
$ sellOrders [$ s] = $ значение [ 'скорости'];
$ S ++;
}
// если ($ значение [ 'типа'] == $ exchangeBuySell [1] && $ Значение [ 'сумма'] == $ engineAmount) {
// $ reserveBTC = ($ reserveBTC - $ значение [ 'сумма'] >= 0? $ ReserveBTC - $ значение [ 'сумма']: 0); //
//
//}
если ($ значения [ 'типа'] == $ exchangeBuySell [0]) {
$ USDO = $ USDO + $ значение [ 'сумма'] * $ значение [ 'скорости']; // USD = сумма от суммы заявки на покупку * ставка
$ buyOrders [$ Ь] = $ значение [ 'скорости'];
$ Б ++;
}
// если ($ значение [ 'типа'] == $ exchangeBuySell [0] && $ Значение [ 'сумма'] == $ engineAmount) {
// // FIXED резерв доллар не был убывающий
// $ reserveUSD = ($ reserveUSD - $ значение [ 'сумма'] * $ значение [ 'скорость'] >= 0? $ ReserveUSD - $ значение [ 'сумма'] * $ значение [ 'скорости']: 0); // USD = сумма от суммы заявки на покупку * ставка
//}
}
/ * Если ($ countIteration < 3 && $ ЗАКАЗОВ) {
rsort ($ buyOrders); // ReverseSort заказы и выбросьте ключи
сортировать ($ sellOrders); // Сортировка заказов и выбросите ключи
если (! @ $ thresholdBuy) $ thresholdBuy = (COUNT ($ sellOrders) <= $ ThresholdOrders? @ $ SellOrders [$ countOrder]: @ $ sellOrders [$ thresholdOrders]); // Заполнит XTH заказа перед торгами
если (! @ $ thresholdSell) $ thresholdSell = (COUNT ($ buyOrders) <= $ ThresholdOrders? @ $ BuyOrders [$ countOrder]: @ $ buyOrders [$ thresholdOrders]); // Заполнит XTH заказа перед торгами
} * /
Теперь // решаемые это установлено в пороговом разделе.
} Еще {
если ($ OrderList [ 'ошибки']! == "нет заказов") {
print_r ($ OrderList);
}
}
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Вычислить ПЕРЕВОД
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ USDB = $ BTCB = $ USDT = $ BTCT = $ BTC = $ USD = 0;
// Вычислить TOTAL мы имеем заказы и баланс и USD / последний BTCTotal
если ($ GOX) $ BTCT = $ возвращающие [ 'возвращение'] [ 'средства'] [ 'BTC'] + $ возвращение [ 'возвращение'] [ 'средства'] [ 'USD'] / $ тикер [ 'тикер' ]['последний'];
если ($ BTC-E) $ BTCT = $ возврата [ 'возврата'] [ 'средства'] [ 'BTC'] + $ BTCO + $ возвращающие [ 'возвращение'] [ 'фондов'] [ 'USD'] / $ тикер [ 'тикер'] [ 'последний'] + $ USDO / $ тикер [ 'тикер'] [ 'последний'];
// Вычислить TOTAL USD мы имеем в ордеров на покупку, продажу заказов, BTC баланс, USD Баланс
если ($ GOX) $ USDT = ($ возвращаемые [ 'возвращение'] [ 'средства'] [ 'BTC']) * $ тикер [ 'тикер'] [ 'последний'] + $ возвращение [ 'возвращение'] [» средства '] [' USD '];
если ($ BTC-E) $ USDT = ($ возвращаемые [ 'возвращение'] [ 'средства'] [ 'BTC'] + $ BTCO) * $ тикер [ 'тикер'] [ 'последний'] + $ USDO + $ вернуться [ 'возвращение'] [ 'средства'] [ 'USD'];
// Вычислить БАЛАНС мы имеем заказов и средств BTCBalance USDBalance
если ($ GOX) $ BTCB = $ возвращающие [ 'возвращение'] [ 'средства'] [ 'BTC'];
если ($ BTC-E) $ BTCB = $ возврата [ 'возврата'] [ 'средства'] [ ''] BTC + $ BTCO;
если (GOX $) $ USDB = $ возвращение [ 'возвращение'] [ 'средств'] [ 'USD'];
если ($ BTC-E) $ USDB = $ возврата [ 'возврата'] [ 'деньги'] [ 'USD'] + $ USDO;
// Вычислить сумму ТОРГОВЫХ мы имеем в фондах и заказах BTCTrade USDTrade
$ BTC = ($ BTCB >= $ MaxBTC? $ MaxBTC - $ BTCO: $ BTCB - $ BTCO);
$ USD = ($ USDB >= $ MaxUSD? $ MaxUSD - $ USDO: $ USDB - $ USDO);
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// Рассчитать стоимость BTC BTCBalance
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ DollarCostTotal = $ dollarCostShares = $ idealSellRate = $ idealSellAmount = $ dollarCostAverage = $ countBuys = 0;
$ CountFilledIterationBuy = $ countFilledIterationSell = $ countFilledIteration = 0;
$ CostBalance = массив ( "общий" => 0, "акция" => 0, "средний" => 0, "идеальный" => 0);
$ CostFilled = массив ( "общий" => 0, "акция" => 0, "средний" => 0, "идеальный" => 0);
$ ProfitFilled = массив ( "общий" => 0, "акция" => 0, "средний" => 0, "идеальный" => 0);
$ BTCremaining = $ BTCB;
если ($ BALANCE) $ BTCremaining = $ BTC * ($ currentBalanceBTC- $ reBalanceBTC);
Еогеасп ($ TradeHistory [ 'возвращение'], как $ ключ => $ Значение) {
// использование DEBUG этой информации для расчета прибыльных сделок / затраты / прибыли
если ($ значение [ 'типа'] == $ exchangeBuySell [0] && $ BTCremaining >= $ MinBidBTC) {
$ CostBalance [ 'всего'] = $ costBalance [ 'всего'] + $ значение [ 'скорости'] * $ значение [ 'сумма'];
$ CostBalance [ 'акции'] = $ costBalance [ 'акции'] + $ значение [ 'сумма']; // $ amountTrade [0]; Всего акции не анализировали / спред
$ BTCremaining = $ BTCremaining - $ значение [ 'сумма'];
$ CountBuys ++;
}
/ *
{
"Успех": 1,
"вернуть":{
"166830": {
"Пара": "btc_usd",
«Тип»: «продать»,
"Количество": 1,
"Скорость": 1,
"Order_id": 343148,
"Is_your_order": 1,
"Метка": 1342445793
}
}
} * /
// совместимость GOX DEBUG
если (@ $ ordersPlaced && array_key_exists ($ значение [ 'order_id'], $ ordersPlaced)) {// PHP Примечание: Undefined индекс: order_id в /arbot/buydownbotBTCG.php на линии 532
$ FilledOrders [$ значение [ 'order_id']] = массив (); // Определить массив
$ FilledOrders [$ значение [ 'order_id']] = $ ordersPlaced [$ значение [ 'order_id']]; // Сохраняет информацию порядка в массиве
$ OrdersFilledIteration [$ countIteration-1] = массив (); // Определить последний массив итерации
$ OrdersFilledIteration [$ countIteration-1] [$ значение [ 'order_id']] = массив (); // Определить последний массив итерации
$ OrdersFilledIteration [$ countIteration-1] [$ значение [ 'order_id']] = $ ordersPlaced [$ значение [ 'order_id']]; // Сохраняет информацию порядка в массиве
снята с охраны ($ ordersPlaced [$ значение [ 'order_id']]);
$ countFilled ++; $ countFilledIteration ++;
если ($ значения [ 'типа'] == $ exchangeBuySell [0]) {
$ CostFilled [ 'всего'] = $ costFilled [ 'всего'] + $ значение [ 'скорости'] * $ значение [ 'сумма'];
$ CostFilled [ 'акции'] = $ costFilled [ 'акции'] + $ значение [ 'сумма']; // $ amountTrade [0]; Всего акции не анализировали / спред
$ countFilledBuy ++; $ countFilledIterationBuy ++;
}
если ($ значения [ 'типа'] == $ exchangeBuySell [1]) {
$ ProfitFilled [ 'всего'] = $ profitFilled [ 'всего'] + $ значение [ 'скорости'] * $ значение [ 'сумма'];
$ ProfitFilled [ 'акции'] = $ profitFilled [ 'акции'] + $ значение [ 'сумма']; // $ amountTrade [0]; Всего акции не анализировали / спред
$ countFilledSell ++; $ countFilledIterationSell ++;
}
}
}
если (@ $ costBalance [ 'акции'] > 0) {
$ CostBalance [ 'средний'] = $ costBalance [ 'общий'] / $ costBalance [ 'акции']; // Общая стоимость / количество акций цена покупки
$ CostBalance [ 'идеал'] = (($ costBalance [ 'всего']) / (1- $ exchangeCommision) / (1- $ exchangeCommision) / (1- $ engineProfit)) / $ costBalance [ 'акции']; / / Средняя стоимость + UtoB комиссионная + BtoU Commision составляет 0% ставка надувательства прибыли
$ Остановить [ 'целевого'] = $ costBalance [ 'идеального'] * 998 * .998 * (1- $ microStopLoss).
} Еще $ остановить [ 'цель'] = 0;
если (@ $ costFilled [ 'акции'] > 0) {
$ CostFilled [ 'средний'] = $ costFilled [ 'общий'] / $ costFilled [ 'акции']; // Общая стоимость / количество акций цена покупки
$ CostFilled [ 'идеал'] = ($ costFilled [ 'средний']) / (1- $ exchangeCommision) / (1- $ exchangeCommision) / (1- $ engineProfit); // Средняя стоимость + UtoB комиссионной + BtoU Commision является 0% ставка надувательства прибыли
}
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
// заголовочный блок Первичный выход
////////////////////////////////////////////////// //////////////////
////////////////////////////////////////////////// //////////////////
$ Сообщение = "\ п";
если (@ $ DEBUG && $ DOT) {печать "\ п"; $ DOT = FALSE; }
печать «\ п \ п \ п \ п \ п»;
Распечатать "************************************************ ********** \ п "; // Печать Separator
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
Распечатать "************************************************ ********** \ п "; // Печать Separator
печать "Начало: {$ dateStart} \ п";
// $ dateCurrent = Дата ( 'Ymd H: я: s');
печать "Текущая:" дата ( 'YMD H: я: S') "\ п";.. // Печать Separator
$ Истекшее = время () - $ начальное время;
$ Tmp1 = $ истекшее / 86400% 1;
$ Tmp2 = $ истекшее / 3600% 24;
$ Tmp3 = $ истекшее / 60% 60;
$ TMP4 = $ истекшее% 60;
печать "Runtime: {$ tmp1}: Дни {$ tmp2}: H {$ tmp3}: {M $ TMP4}: S \ п";
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
// $ tmp1 = круглый ($ остановки [ 'цель'], 2);
$ Tmp1 = (? $ STOPLOSS "АКТИВНЫЙ": ($ остановки [ 'цель'] == 0 "НЕТ ИНВЕСТИЦИЙ": круглые ($ остановки [ 'цель'], 2)));
печать "Итерация: {$ countIteration} Код: \ $ {$ тикер [ 'тикер'] [ 'последний']} ***** StopLoss: {$ tmp1} ***** \ п"; // Печать Separator
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
печать «---------------- Торговля Целевая информация ---------------- \ п»;
печать "Пороговая: Стоимость: {$ exchangeCommision}% сделки: {$} Пороговая Micro: {$ microThreshold} \ п";
если (@ $ ЗАКАЗЫ || @ $ статика) печать «Цели: За: \ $ {$ thresholdBuy} Последнее: \ $ {$ тикер [ 'тикер'] [ 'последний']} В: \ $ {$ thresholdSell} \ п ";
если ($ MICRO && ! $ STOPLOSS) печать "Микро Цели: За: \ $ {$ microThresholdBuy} Tick: \ $ {$} microTicker Under: \ $ {$ microThresholdSell} \ п";
если ($ StopLoss) печать "REBUY Цели: Over: {$ остановить [ 'над']} Tick: {$ остановки [ 'тикер']} Under: {$ остановить [ 'под']} \ п";
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
печать «------------------- фонды Информация ------------------- \ п»;
$ Tmp1 = круглый ($ BTCT, 2); $ tmp2 = круглый ($ USDT, 2);
печать "Cash Out: BTC: {$} tmp1 USD: \ $ {$ tmp2} \ п";
$ Tmp1 = круглый ($ BTCB, 2); $ tmp2 = круглый ($ USDB, 2);
печать "Баланс: BTC: {$} tmp1 USD: \ $ {$ tmp2} \ п";
печать "Максимумы: BTC: {$} maxBTC USD: \ $ {$ maxUSD} \ п";
$ EngineAmount = макс ($ BTCB, $ USDB / $ тиккера [ 'тиккера'] [ 'последняя']);
$ EngineAmount = мин ($ engineAmount, $ microAmount);
$ EngineAmount = круглый ($ engineAmount, 8);
$ Tmp1 = круглый ($ engineAmount, 2);
// DEBUG не совместим с другими двигателями, необходимых для создания tradeAmount или buyamount и sellamount.
печать "EngineAmount: {$ tmp1} продает: {$ engineSellDivisor} Покупает: {$} engineBuyDivisor прибыль: {$ engineProfit} \ п";
$ Tmp1 = круглый ($ BTC, 2); $ tmp2 = круглый ($ USD, 2);
печать "Передается: BTC: {$} tmp1 USD: \ $ {$ tmp2} \ п";
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
печать «------------------- Информация для заказа ------------------- \ п»;
печать "Open: Покупает: {$ B} продает: {$ s} \ п";
печать "Размещено: Действительно: {$ countValid} Invalid {$ countInValid} Отменено: {$ countCancelled} \ п";
печать "Выполнил: Покупает: {$ countFilledBuy} Итого: {$} countFilled продает: {$ countFilledSell} \ п";
печать "Последний запуск: Покупает: {$ countFilledIterationBuy} Итого: {$} countFilledIteration продает: {$ countFilledIterationSell} \ п";
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
печать «------------------- Стоимость информация ------------------- \ п»;
если (@ $ costBalance [ 'акции'] > 0) {
$ Tmp1 = круглый ($ costBalance [ 'всего'], 2);
$ Tmp2 = круглый ($ costBalance [ 'акции'], 2);
$ Tmp3 = круглый ($ costBalance [ 'средний'], 2);
$ TMP4 = круглый ($ costBalance [ 'идеал'], 2);
печать "Расходы Остаток: Всего: {$ tmp1} Акции: {$} tmp2 Средний балл: {$ tmp3} Идеальные: {$ TMP4} \ п";
$ Tmp1 = $ tmp2 = $ tmp3 = $ TMP4 = NULL;
} Еще $ costBalance [ 'идеал'] = $ тикер [ 'тикер'] [ 'последний'] * 2;
если (@ $ costFilled [ 'акции'] > 0) {
$ Tmp1 = круглый ($ costFilled [ 'всего'], 2);
$ Tmp2 = круглый ($ costFilled [ 'акции'], 2);
$ Tmp3 = круглый ($ costFilled [ 'средний'], 2);
$ TMP4 = круглый ($ costFilled [ 'идеал'], 2);
печать "Стоимость заказа: Всего: {$ tmp1} Акции: {$} tmp2 Средний балл: {$ tmp3} Идеальные: {$ TMP4} \ п";
$ Tmp1 = $ tmp2 = $ tmp3 = $ TMP4 = NULL;
}
если ((@ $ costFilled [ 'акции'] == 0) && (@ $ CostBalance [ 'акции'] == 0)) {
печать «Стоимость заказа: не занимающее какую-либо BTC \ п»;
}
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
печать "------------------- Информация Profit ------------------- \ п";
если ($ countIteration < 3) {
$ Прибыль = массив ( 'начальная' => Массив (= '' balanceBTC> $ BTCB, 'balanceUSD' => $ USDB "тикер => $ Тикер [ 'тикер'] [ 'последний'] = 'totalBTC'> $ BTCT, 'totalUSD' => $ USDT));
}
//
$ Прибыли [ 'купить'] = массив (= 'amountBTC'> 0, 'amountUSD' => 0);
$ Прибыли [ 'продать'] = массив (= 'amountBTC'> 0, 'amountUSD' => 0);
если (@ $ filledOrders) {
Еогеасп ($ filledOrders как $ ключ => $ Значение) {
если ($ значения [ 'типа'] == $ exchangeBuySell [0]) {
$ Прибыли [ 'купить'] [ 'amountBTC'] = $ прибыли [ 'купить'] [ 'amountBTC'] + $ значение [ 'сумма'];
$ Прибыли [ 'купить'] [ 'amountUSD'] = $ прибыли [ 'купить'] [ 'amountUSD'] + $ значение [ 'скорость'] * $ значение [ 'сумма'];
}
если ($ значения [ 'типа'] == $ exchangeBuySell [1]) {
$ Прибыли [ 'продать'] [ 'amountBTC'] = $ прибыли [ 'продать'] [ 'amountBTC'] + $ значение [ 'сумма'];
$ Прибыли [ 'продать'] [ 'amountUSD'] = $ прибыли [ 'продать'] [ 'amountUSD'] + $ значение [ 'скорости'] * $ значение [ 'сумма'];
}
}
// FIXED PHP Предупреждение: Деление на ноль в /arbot/buydownbotBTC.php на линии 659
если ($ прибыли [ 'купить'] [ 'amountBTC'] > 0) $ прибыли [ 'купить'] [ 'стоимость'] = круглый ($ прибыли [ 'купить'] [ 'amountUSD'] / $ прибыли [ 'купить'] [ 'amountBTC'], 2);
если ($ прибыли [ 'продать'] [ 'amountBTC'] > 0) $ прибыли [ 'продать'] [ 'стоимость'] = круглый ($ прибыли [ 'продать'] [ 'amountUSD'] / $ прибыли [ 'продать'] [ 'amountBTC'], 2);
}
//Первоначальный баланс
$ Tmp1 = круглый ($ прибыль [ 'начальная'] [ 'balanceBTC'], 2);
$ Tmp2 = круглый ($ прибыль [ 'начальная'] [ 'balanceUSD'], 2);
печать "начальный баланс: BTC: {$ tmp1} USD: {$ tmp2} Рейтинг: {$ прибыли [ 'начальная'] [ 'тикер']} \ п";
//Текущий баланс
$ Tmp1 = круглый ($ BTCB, 2);
$ Tmp2 = круглый ($ USDB, 2);
печать "Текущий баланс: BTC: {$ tmp1} USD: {$ tmp2} Рейтинг: {$ тикер [ 'тикер'] [ 'последний']} \ п";
// Difference
$ Tmp1 = круглый ($ USDB - $ прибыли [ 'начальная'] [ 'balanceUSD'], 2);
$ Tmp2 = круглый ($ BTCB - $ прибыли [ 'начальная'] [ 'balanceBTC'], 2);
$ Tmp3 = круглый (($ тикер [ 'тикер'] [ 'последний'] - $ прибыли [ 'начальная'] [ 'тикер']), 2);
печать "Разница: BTC: {$ tmp2} USD: {$ tmp1} Рейтинг: {$ tmp3} \ п";
если (@ $ прибыли [ 'купить'] [ 'amountBTC'] > 0) {
// BTC продажи {amountBTC} {} {costBTC TotalCost}
$ Tmp1 = круглый ($ прибыли [ 'купить'] [ 'amountBTC'], 2);
$ Tmp2 = круглый ($ прибыли [ 'купить'] [ 'стоимость'], 2);
$ Tmp3 = круглый ($ прибыли [ 'купить'] [ 'amountUSD'], 2);
печать "Trade Покупает: BTC: {$ tmp1} Рейтинг: {$ tmp2} Итого: {$ tmp3} \ п";
}
если (@ $ прибыли [ 'продать'] [ 'amountBTC'] > 0) {
// BTC продано {amountBTC} {} {costBTC totalprofit}
$ Tmp1 = круглый ($ прибыли [ 'продать'] [ 'amountBTC'], 2);
$ Tmp2 = круглый ($ прибыли [ 'продать'] [ 'стоимость'], 2);
$ Tmp3 = круглый ($ прибыли [ 'продать'] [ 'amountUSD'], 2);
печать "Trade Sells: BTC: {$ tmp1} Рейтинг: {$ tmp2} Итого: {$ tmp3} \ п";
}
// Прибыль
// продать - купить + BTCholdings * последний * комиссионный - initialBTCbalance * initialLast * комиссионные
$ Tmp1 = круглый ($ прибыли [ 'продать'] [ 'amountUSD'] - $ прибыли [ 'купить'] [ 'amountUSD'] + ($ BTCB * $ тикер [ 'тикер'] [ 'последний'] * 998. ) - ($ прибыли [ 'начальная'] [ 'balanceBTC'] * $ прибыли [ 'начальная'] [ 'тикер'] * 998), 2).
$ Tmp2 = круглый ($ USDT - $ прибыли [ 'начальная'] [ 'totalUSD'] - $ tmp1,2);
печать "Прибыль от торговли: {$ tmp1} \ п";
печать "Нереализованные Прибыль: {$ tmp2} \ п";
// BTC Оценка = пуск * BTC начать скорость - startbtc * скорость тока
$ Tmp1 = круглый ($ прибыли [ 'начальная'] [ 'totalBTC'] * $ прибыли [ 'начальная'] [ 'тикер'], 2);
$ Tmp2 = круглый ($ прибыли [ 'начальная'] [ 'totalBTC'] * $ тикер [ 'тикер'] [ 'последний'], 2);
$ TMP4 = круглый ($ tmp1 - $ tmp2,2);
печать "BTC УДОВЛЕТВОРЕНИЯ: Начало: {$ tmp1} Ток: {$ tmp2} Разница: {$ TMP4} \ п";
// Run Value = прибыль - оценка
// $ tmp1 = круглый ($ прибыли [ 'начальная'] [ 'balanceBTC'] * $ прибыли [ 'начальная'] [ 'тикер'] *. 998 + $ прибыли [ 'начальная'] [ 'balanceUSD'], 2 );
$ Tmp3 = круглый ($ USDT - $ прибыли [ 'начальная'] [ 'totalUSD'], 2);
печать "Программа Значение: {$ tmp3} \ п";
$ Сообщение = $ сообщение. "Программа Значение: {$ tmp3} \ п";
$ Tmp1 = $ tmp2 = $ tmp3 = $ TMP4 = 0;
Распечатать "------------------------------------------------ ---------- \ п "; // Печать Separator
