func Exchange(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "Exchange"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 3600
} else {
d.sleepTime = 60
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
blockId, err := d.GetConfirmedBlockId()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
var myPrefix string
community, err := d.GetCommunityUsers()
if len(community) > 0 {
adminUserId, err := d.GetPoolAdminUserId()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
myPrefix = utils.Int64ToStr(adminUserId) + "_"
} else {
myPrefix = ""
}
eConfig, err := d.GetMap(`SELECT * FROM e_config`, "name", "value")
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
confirmations := utils.StrToInt64(eConfig["confirmations"])
mainDcAccount := utils.StrToInt64(eConfig["main_dc_account"])
// все валюты, с которыми работаем
currencyList, err := utils.EGetCurrencyList()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// ++++++++++++ reduction ++++++++++++
// максимальный номер блока для процентов. Чтобы брать только новые
maxReductionBlock, err := d.Single(`SELECT max(block_id) FROM e_reduction`).Int64()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// если есть свежая reduction, то нужно остановить торги
reduction, err := d.Single(`SELECT block_id FROM reduction WHERE block_id > ? and pct > 0`, maxReductionBlock).Int64()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if reduction > 0 {
err = d.ExecSql(`INSERT INTO e_reduction_lock (time) VALUES (?)`, utils.Time())
if err != nil {
log.Error("%v", utils.ErrInfo(err))
}
}
// если уже прошло 10 блоков с момента обнаружения reduction, то производим сокращение объема монет
rows, err := d.Query(d.FormatQuery(`SELECT pct, currency_id, time, block_id FROM reduction WHERE block_id > ? AND
block_id < ?`), maxReductionBlock, blockId-confirmations)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var pct float64
var currencyId, rTime, blockId int64
err = rows.Scan(&pct, ¤cyId, &rTime, &blockId)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// $k = (100-$row['pct'])/100;
k := (100 - pct) / 100
// уменьшаем все средства на счетах
err = d.ExecSql(`UPDATE e_wallets SET amount = amount * ? WHERE currency_id = ?`, k, currencyId)
// уменьшаем все средства на вывод
err = d.ExecSql(`UPDATE e_withdraw SET amount = amount * ? WHERE currency_id = ? AND close_time = 0`, k, currencyId)
// уменьшаем все ордеры на продажу
err = d.ExecSql(`UPDATE e_orders SET amount = amount * ?, begin_amount = begin_amount * ? WHERE sell_currency_id = ?`, k, k, currencyId)
err = d.ExecSql(`INSERT INTO e_reduction (
time,
block_id,
currency_id,
pct
)
VALUES (
?,
?,
?,
?
)`, rTime, blockId, currencyId, pct)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
rows.Close()
// ++++++++++++ DC ++++++++++++
/*
* Важно! отключать в кроне при обнулении данных в БД
*
* 1. Получаем инфу о входящих переводах и начисляем их на счета юзеров
* 2. Обновляем проценты
* 3. Чистим кол-во отправленных смс-ок
* */
nodePrivateKey, err := d.GetNodePrivateKey(myPrefix)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
/*
* Получаем инфу о входящих переводах и начисляем их на счета юзеров
* */
// если всё остановлено из-за найденного блока с reduction, то входящие переводы не обрабатываем
reductionLock, err := utils.EGetReductionLock()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if reductionLock > 0 {
if d.dPrintSleep(utils.ErrInfo("reductionLock"), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
rows, err = d.Query(d.FormatQuery(`
SELECT amount, id, block_id, type_id, currency_id, to_user_id, time, comment, comment_status
FROM my_dc_transactions
WHERE type = 'from_user' AND
block_id < ? AND
exchange_checked = 0 AND
status = 'approved' AND
to_user_id = ?
ORDER BY id DESC`), blockId-confirmations, mainDcAccount)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var amount float64
var id, blockId, typeId, currencyId, toUserId, txTime int64
var comment, commentStatus string
err = rows.Scan(&amount, &id, &blockId, &typeId, ¤cyId, &toUserId, &txTime, &comment, &commentStatus)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// отметим exchange_checked=1, чтобы больше не брать эту тр-ию
err = d.ExecSql(`UPDATE my_dc_transactions SET exchange_checked = 1 WHERE id = ?`, id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// вначале нужно проверить, точно ли есть такой перевод в блоке
binaryData, err := d.Single(`SELECT data FROM block_chain WHERE id = ?`, blockId).Bytes()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
p := new(dcparser.Parser)
p.DCDB = d.DCDB
p.BinaryData = binaryData
p.ParseDataLite()
for _, txMap := range p.TxMapArr {
// пропускаем все ненужные тр-ии
if utils.BytesToInt64(txMap["type"]) != utils.TypeInt("SendDc") {
continue
}
log.Debug("md5hash %s", txMap["md5hash"])
// если что-то случится с таблой my_dc_transactions, то все ввода на биржу будут зачислены по новой
// поэтому нужно проверять e_adding_funds
exists, err := d.Single(`SELECT id FROM e_adding_funds WHERE hex(tx_hash) = ?`, string(txMap["md5hash"])).Int64()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
log.Debug("exists %d", exists)
if exists != 0 {
continue
}
log.Debug("user_id = %d / typeId = %d / currency_id = %d / currencyId = %d / amount = %f / amount = %f / comment = %s / comment = %s / to_user_id = %d / toUserId = %d ", utils.BytesToInt64(txMap["user_id"]), typeId, utils.BytesToInt64(txMap["currency_id"]), currencyId, utils.BytesToFloat64(txMap["amount"]), amount, string(utils.BinToHex(txMap["comment"])), comment, utils.BytesToInt64(txMap["to_user_id"]), toUserId)
// сравнение данных из таблы my_dc_transactions с тем, что в блоке
if utils.BytesToInt64(txMap["user_id"]) == typeId && utils.BytesToInt64(txMap["currency_id"]) == currencyId && utils.BytesToFloat64(txMap["amount"]) == amount && string(utils.BinToHex(txMap["comment"])) == comment && utils.BytesToInt64(txMap["to_user_id"]) == toUserId {
decryptedComment := comment
if commentStatus == "encrypted" {
// расшифруем коммент
block, _ := pem.Decode([]byte(nodePrivateKey))
if block == nil || block.Type != "RSA PRIVATE KEY" {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
private_key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment_, err := rsa.DecryptPKCS1v15(rand.Reader, private_key, utils.HexToBin(comment))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment = string(decryptedComment_)
// запишем расшифрованный коммент, чтобы потом можно было найти перевод в ручном режиме
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET comment = ?, comment_status = 'decrypted' WHERE id = ?", decryptedComment, id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// возможно юзер сделал перевод в той валюте, которая у нас на бирже еще не торгуется
if len(currencyList[currencyId]) == 0 {
log.Error("currencyId %d not trading", currencyId)
continue
}
// возможно, что чуть раньше было reduction, а это значит, что все тр-ии,
// которые мы ещё не обработали и которые были До блока с reduction нужно принимать с учетом reduction
// т.к. средства на нашем счете уже урезались, а вот те, что после reduction - остались в том виде, в котором пришли
lastReduction, err := d.OneRow("SELECT block_id, pct FROM reduction WHERE currency_id = ? ORDER BY block_id", currencyId).Int64()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if blockId <= lastReduction["block_id"] {
// сумму с учетом reduction
k0 := (100 - lastReduction["pct"]) / 100
amount = amount * float64(k0)
}
// начисляем средства на счет того, чей id указан в комменте
r, _ := regexp.Compile(`(?i)\s*#\s*([0-9]+)\s*`)
user := r.FindStringSubmatch(decryptedComment)
if len(user) == 0 {
log.Error("len(user) == 0")
continue
}
log.Debug("user %s", user[1])
// user_id с биржевой таблы
uid := utils.StrToInt64(user[1])
userAmountAndProfit := utils.EUserAmountAndProfit(uid, currencyId)
newAmount_ := userAmountAndProfit + amount
utils.UpdEWallet(uid, currencyId, utils.Time(), newAmount_, true)
// для отчетности запишем в историю
err = d.ExecSql(`
INSERT INTO e_adding_funds (
user_id,
currency_id,
time,
amount,
tx_hash
)
VALUES (
?,
?,
?,
?,
?
)`, uid, currencyId, txTime, amount, string(txMap["md5hash"]))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
}
}
rows.Close()
/*
* Обновляем проценты
* */
// максимальный номер блока для процентов. Чтобы брать только новые
maxPctBlock, err := d.Single(`SELECT max(block_id) FROM e_user_pct`).Int64()
log.Debug(`SELECT time, block_id, currency_id, user FROM pct WHERE block_id < ` + utils.Int64ToStr(blockId-confirmations) + ` AND block_id > ` + utils.Int64ToStr(maxPctBlock))
rows, err = d.Query(d.FormatQuery(`SELECT time, block_id, currency_id, user FROM pct WHERE block_id < ? AND block_id > ?`), blockId-confirmations, maxPctBlock)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var pct float64
var pTime, blockId, currencyId int64
err = rows.Scan(&pTime, &blockId, ¤cyId, &pct)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
d.ExecSql(`
INSERT INTO e_user_pct (
time,
block_id,
currency_id,
pct
)
VALUES (
?,
?,
?,
?
)`, pTime, blockId, currencyId, pct)
}
rows.Close()
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}
func (p *Parser) SendDcFront() error {
err := p.generalCheck()
if err != nil {
return p.ErrInfo(err)
}
verifyData := map[string]string{"from_user_id": "bigint", "to_user_id": "bigint", "currency_id": "bigint", "amount": "amount", "commission": "amount", "comment": "comment"}
err = p.CheckInputData(verifyData)
if err != nil {
return p.ErrInfo(err)
}
if p.TxMaps.Float64["amount"] < 0.01 { // 0.01 - минимальная сумма
return p.ErrInfo("amount")
}
// проверим, существует ли такая валюта в таблиуе DC-валют
checkCurrency, err := p.CheckCurrency(p.TxMaps.Int64["currency_id"])
if !checkCurrency {
// если нет, то проверяем список CF-валют
checkCurrency, err := p.CheckCurrencyCF(p.TxMaps.Int64["currency_id"])
if err != nil {
return p.ErrInfo(err)
}
if !checkCurrency {
return p.ErrInfo("currency_id")
}
}
nodeCommission, err := p.getMyNodeCommission(p.TxMaps.Int64["currency_id"], p.TxUserID, p.TxMaps.Float64["amount"])
if err != nil {
return p.ErrInfo(err)
}
// проверим, удовлетворяет ли нас комиссия, которую предлагает юзер
if p.TxMaps.Float64["commission"] < nodeCommission {
return p.ErrInfo(fmt.Sprintf("commission %v<%v", p.TxMaps.Float64["commission"], nodeCommission))
}
if p.BlockData != nil && p.BlockData.BlockId <= consts.ARBITRATION_BLOCK_START {
for i := 0; i < 5; i++ {
p.TxMaps.Float64["arbitrator"+utils.IntToStr(i)+"_commission"] = 0 // для check_sender_money
}
forSign := fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s", p.TxMap["type"], p.TxMap["time"], p.TxMap["user_id"], p.TxMap["to_user_id"], p.TxMap["amount"], p.TxMap["commission"], utils.BinToHex(p.TxMap["comment"]), p.TxMap["currency_id"])
CheckSignResult, err := utils.CheckSign(p.PublicKeys, forSign, p.TxMap["sign"], false)
if err != nil {
return p.ErrInfo(err)
}
if !CheckSignResult {
return p.ErrInfo("incorrect sign")
}
} else {
dupArray := make(map[int64]int64)
for i := 0; i < 5; i++ {
arbitrator__commission := "arbitrator" + utils.IntToStr(i) + "_commission"
arbitrator_ := "arbitrator" + utils.IntToStr(i)
if !utils.CheckInputData(p.TxMap[arbitrator__commission], "amount") {
return p.ErrInfo("arbitrator_commission")
}
if !utils.CheckInputData(p.TxMap[arbitrator_], "bigint") {
return p.ErrInfo("arbitrator")
}
// если указал ID арбитра, то должна быть комиссия для него
if p.TxMaps.Int64[arbitrator_] > 0 && p.TxMaps.Float64[arbitrator__commission] < 0.01 {
return p.ErrInfo("arbitrator_commission")
}
// на всяк случай не даем арбитрам возможность быть арбитрами самим себе
if p.TxMaps.Int64[arbitrator_] == p.TxUserID {
return p.ErrInfo("arbitrator = user_id")
}
if p.TxMaps.Int64[arbitrator_] > 0 {
dupArray[utils.BytesToInt64(p.TxMap[arbitrator_])]++
if dupArray[utils.BytesToInt64(p.TxMap[arbitrator_])] > 1 {
return p.ErrInfo("doubles")
}
}
if p.TxMaps.Int64[arbitrator_] > 0 {
arbitrator := p.TxMap[arbitrator_]
// проверим, является ли арбитром указанный user_id
arbitratorConditionsJson, err := p.Single("SELECT conditions FROM arbitrator_conditions WHERE user_id = ?", utils.BytesToInt64(arbitrator)).Bytes()
if err != nil {
return p.ErrInfo(err)
}
arbitratorConditionsMap := make(map[string][5]string)
err = json.Unmarshal(arbitratorConditionsJson, &arbitratorConditionsMap)
// арбитр к этому моменту мог передумать и убрать свои условия, уйдя из арбитров для новых сделок поставив [0] что вызовет тут ошибку
if err != nil {
log.Debug("arbitratorConditionsJson", arbitratorConditionsJson)
return p.ErrInfo(err)
}
// проверим, работает ли выбранный арбитр с валютой данной сделки
var checkCurrency int64
if p.TxMaps.Int64["currency_id"] > 1000 {
checkCurrency = 1000
} else {
checkCurrency = p.TxMaps.Int64["currency_id"]
}
if len(arbitratorConditionsMap[utils.Int64ToStr(checkCurrency)]) == 0 {
return p.ErrInfo("len(arbitratorConditionsMap[checkCurrency]) == 0")
}
// указан ли этот арбитр в списке доверенных у продавца
sellerArbitrator, err := p.Single("SELECT user_id FROM arbitration_trust_list WHERE user_id = ? AND arbitrator_user_id = ?", p.TxMaps.Int64["to_user_id"], utils.BytesToInt64(arbitrator)).Int64()
if err != nil {
return p.ErrInfo(err)
}
if sellerArbitrator == 0 {
return p.ErrInfo("sellerArbitrator == 0")
}
// указан ли этот арбитр в списке доверенных у покупателя
buyerArbitrator, err := p.Single("SELECT user_id FROM arbitration_trust_list WHERE user_id = ? AND arbitrator_user_id = ?", p.TxMaps.Int64["from_user_id"], utils.BytesToInt64(arbitrator)).Int64()
if err != nil {
return p.ErrInfo(err)
}
if buyerArbitrator == 0 {
return p.ErrInfo("buyerArbitrator == 0")
}
// согласен ли продавец на манибек
arbitrationDaysRefund, err := p.Single("SELECT arbitration_days_refund FROM users WHERE user_id = ?", p.TxMaps.Int64["to_user_id"]).Int64()
if err != nil {
return p.ErrInfo(err)
}
if arbitrationDaysRefund == 0 {
return p.ErrInfo("buyerArbitrator == 0")
}
// готов ли арбитр рассматривать такую сумму сделки
currencyIdStr := utils.Int64ToStr(p.TxMaps.Int64["currency_id"])
if p.TxMaps.Float64["amount"] < utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][0]) ||
(p.TxMaps.Float64["amount"] > utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][1]) && utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][1]) > 0) {
return p.ErrInfo("amount")
}
// мин. комиссия, на которую согласен арбитр
minArbitratorCommission := utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][4]) / 100 * p.TxMaps.Float64["amount"]
if minArbitratorCommission > utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][3]) && utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][3]) > 0 {
minArbitratorCommission = utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][3])
}
if minArbitratorCommission < utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][2]) {
minArbitratorCommission = utils.StrToFloat64(arbitratorConditionsMap[currencyIdStr][2])
}
if utils.BytesToFloat64(p.TxMap[arbitrator__commission]) < minArbitratorCommission {
return p.ErrInfo(" < minArbitratorCommission")
}
}
}
forSign := fmt.Sprintf("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", p.TxMap["type"], p.TxMap["time"], p.TxMap["user_id"], p.TxMap["to_user_id"], p.TxMap["amount"], p.TxMap["commission"], p.TxMap["arbitrator0"], p.TxMap["arbitrator1"], p.TxMap["arbitrator2"], p.TxMap["arbitrator3"], p.TxMap["arbitrator4"], p.TxMap["arbitrator0_commission"], p.TxMap["arbitrator1_commission"], p.TxMap["arbitrator2_commission"], p.TxMap["arbitrator3_commission"], p.TxMap["arbitrator4_commission"], utils.BinToHex(p.TxMap["comment"]), p.TxMap["currency_id"])
CheckSignResult, err := utils.CheckSign(p.PublicKeys, forSign, p.TxMap["sign"], false)
if err != nil {
return p.ErrInfo(err)
}
if !CheckSignResult {
return p.ErrInfo("incorrect sign")
}
}
/*
wallets_buffer сделан не для защиты от двойной траты, а для того, чтобы нода, которая генерит блок не записала
двойное списание в свой блок, который будет отправлен другим нодам и будет ими отвергнут.
Для тр-ий типа new_forex_order используется простой запрет на запись в блок тр-ии new_forex_order+new_forex_order или
new_forex_order+send_dc и пр.
защита от двойного списания на основе даннных из блока, полученного из сети заключается в постепенной обработке
тр-ий путем проверки front_ и занесения данных в БД (ParseDataFull).
*/
amountAndCommission, err := p.checkSenderMoney(p.TxMaps.Int64["currency_id"], p.TxMaps.Int64["from_user_id"], p.TxMaps.Float64["amount"], p.TxMaps.Float64["commission"], p.TxMaps.Float64["arbitrator0_commission"], p.TxMaps.Float64["arbitrator1_commission"], p.TxMaps.Float64["arbitrator2_commission"], p.TxMaps.Float64["arbitrator3_commission"], p.TxMaps.Float64["arbitrator4_commission"])
if err != nil {
return p.ErrInfo(err)
}
// существует ли юзер-получатель
err = p.CheckUser(p.TxMaps.Int64["to_user_id"])
if err != nil {
return p.ErrInfo(err)
}
err = p.checkSpamMoney(p.TxMaps.Int64["currency_id"], p.TxMaps.Float64["amount"])
if err != nil {
return p.ErrInfo(err)
}
// вычитаем из wallets_buffer
// amount_and_commission взято из check_sender_money()
err = p.updateWalletsBuffer(amountAndCommission, p.TxMaps.Int64["currency_id"])
if err != nil {
return p.ErrInfo(err)
}
return nil
}
func Shop(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "Shop"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 3600
} else {
d.sleepTime = 120
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
myBlockId, err := d.GetMyBlockId()
blockId, err := d.GetBlockId()
if myBlockId > blockId {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
currencyList, err := d.GetCurrencyList(false)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
// нужно знать текущий блок, который есть у большинства нодов
blockId, err = d.GetConfirmedBlockId()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
// сколько должно быть подтверждений, т.е. кол-во блоков сверху
confirmations := int64(5)
// берем всех юзеров по порядку
community, err := d.GetCommunityUsers()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
for _, userId := range community {
privateKey := ""
myPrefix := utils.Int64ToStr(userId) + "_"
allTables, err := d.GetAllTables()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if !utils.InSliceString(myPrefix+"my_keys", allTables) {
continue
}
// проверим, майнер ли
minerId, err := d.GetMinerId(userId)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if minerId > 0 {
// наш приватный ключ нода, которым будем расшифровывать комменты
privateKey, err = d.GetNodePrivateKey(myPrefix)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// возможно, что комменты будут зашифрованы юзерским ключем
if len(privateKey) == 0 {
privateKey, err = d.GetMyPrivateKey(myPrefix)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// если это еще не майнер и админ ноды не указал его приватный ключ в табле my_keys, то $private_key будет пуст
if len(privateKey) == 0 {
continue
}
myData, err := d.OneRow("SELECT shop_secret_key, shop_callback_url FROM " + myPrefix + "my_table").String()
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// Получаем инфу о входящих переводах и начисляем их на счета юзеров
dq := d.GetQuotes()
rows, err := d.Query(d.FormatQuery(`
SELECT id, block_id, type_id, currency_id, amount, to_user_id, comment_status, comment
FROM `+dq+myPrefix+`my_dc_transactions`+dq+`
WHERE type = 'from_user' AND
block_id < ? AND
merchant_checked = 0 AND
status = 'approved'
ORDER BY id DESC
`), blockId-confirmations)
if err != nil {
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var id, block_id, type_id, currency_id, to_user_id int64
var comment_status, comment string
var amount float64
err = rows.Scan(&id, &block_id, &type_id, ¤cy_id, &amount, &to_user_id, &comment_status, &comment)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if len(myData["shop_callback_url"]) == 0 {
// отметим merchant_checked=1, чтобы больше не брать эту тр-ию
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET merchant_checked = 1 WHERE id = ?", id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
continue
}
// вначале нужно проверить, точно ли есть такой перевод в блоке
binaryData, err := d.Single("SELECT data FROM block_chain WHERE id = ?", blockId).Bytes()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
p := new(dcparser.Parser)
p.DCDB = d.DCDB
p.BinaryData = binaryData
p.ParseDataLite()
for _, txMap := range p.TxMapArr {
// пропускаем все ненужные тр-ии
if utils.BytesToInt64(txMap["type"]) != utils.TypeInt("SendDc") {
continue
}
// сравнение данных из таблы my_dc_transactions с тем, что в блоке
if utils.BytesToInt64(txMap["user_id"]) == userId && utils.BytesToInt64(txMap["currency_id"]) == currency_id && utils.BytesToFloat64(txMap["amount"]) == amount && string(utils.BinToHex(txMap["comment"])) == comment && utils.BytesToInt64(txMap["to_user_id"]) == to_user_id {
decryptedComment := comment
// расшифруем коммент
if comment_status == "encrypted" {
block, _ := pem.Decode([]byte(privateKey))
if block == nil || block.Type != "RSA PRIVATE KEY" {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
private_key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment_, err := rsa.DecryptPKCS1v15(rand.Reader, private_key, []byte(comment))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
decryptedComment = string(decryptedComment_)
// запишем расшифрованный коммент, чтобы потом можно было найти перевод в ручном режиме
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET comment = ?, comment_status = 'decrypted' WHERE id = ?", decryptedComment, id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// возможно, что чуть раньше было reduction, а это значит, что все тр-ии,
// которые мы ещё не обработали и которые были До блока с reduction нужно принимать с учетом reduction
// т.к. средства на нашем счете уже урезались, а вот те, что после reduction - остались в том виде, в котором пришли
lastReduction, err := d.OneRow("SELECT block_id, pct FROM reduction WHERE currency_id = ? ORDER BY block_id", currency_id).Int64()
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if blockId <= lastReduction["block_id"] {
// сумму с учетом reduction
k0 := (100 - lastReduction["pct"]) / 100
amount = amount * float64(k0)
}
// делаем запрос к callback скрипту
r, _ := regexp.Compile(`(?i)\s*#\s*([0-9]+)\s*`)
order := r.FindStringSubmatch(decryptedComment)
orderId := 0
if len(order) > 0 {
orderId = utils.StrToInt(order[1])
}
txId := id
sign := fmt.Sprintf("%v:%v:%v:%v:%v:%v:%v:%v", amount, currencyList[currency_id], orderId, decryptedComment, txMap["user_id"], blockId, txId, myData["shop_secret_key"])
data := url.Values{}
data.Add("amount", utils.Float64ToStrPct(amount))
data.Add("currency", currencyList[currency_id])
data.Add("order_id", utils.IntToStr(orderId))
data.Add("message", decryptedComment)
data.Add("user_id", string(txMap["user_id"]))
data.Add("block_id", string(txMap["block_id"]))
data.Add("tx_id", utils.Int64ToStr(txId))
data.Add("sign", sign)
client := &http.Client{}
req, err := http.NewRequest("POST", myData["shop_callback_url"], bytes.NewBufferString(data.Encode()))
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
req.Header.Add("Content-Length", utils.IntToStr(len(data.Encode())))
resp, err := client.Do(req)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
//contents, _ := ioutil.ReadAll(resp.Body)
if resp.StatusCode == 200 {
// отметим merchant_checked=1, чтобы больше не брать эту тр-ию
err = d.ExecSql("UPDATE "+myPrefix+"my_dc_transactions SET merchant_checked = 1 WHERE id = ?", id)
if err != nil {
rows.Close()
if d.dPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
}
}
}
rows.Close()
}
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}
