20fd7aaeb1
- Processing of Deposit/Withdraw request for FLO/Rupee. - renamed database's TxQuery to transaction
686 lines
34 KiB
JavaScript
686 lines
34 KiB
JavaScript
const floGlobals = require("./floGlobals");
|
|
|
|
var net_FLO_price; //container for FLO price (from API or by model)
|
|
var DB; //container for database
|
|
const REFRESH_INTERVAL = 60 * 1000; //1 min
|
|
|
|
const tokenAPI = {
|
|
fetch_api: function(apicall) {
|
|
return new Promise((resolve, reject) => {
|
|
console.log(floGlobals.tokenURL + apicall);
|
|
fetch(floGlobals.tokenURL + apicall).then(response => {
|
|
if (response.ok)
|
|
response.json().then(data => resolve(data));
|
|
else
|
|
reject(response)
|
|
}).catch(error => reject(error))
|
|
})
|
|
},
|
|
getBalance: function(floID, token = 'rupee') {
|
|
return new Promise((resolve, reject) => {
|
|
this.fetch_api(`api/v1.0/getFloAddressBalance?token=${token}&floAddress=${floID}`)
|
|
.then(result => resolve(result.balance || 0))
|
|
.catch(error => reject(error))
|
|
})
|
|
},
|
|
getTx: function(txID) {
|
|
return new Promise((resolve, reject) => {
|
|
this.fetch_api(`api/v1.0/getTransactionDetails/${txID}`).then(res => {
|
|
if (res.result === "error")
|
|
reject(res.description);
|
|
else if (!res.parsedFloData)
|
|
reject("Data piece (parsedFloData) missing");
|
|
else if (!res.transactionDetails)
|
|
reject("Data piece (transactionDetails) missing");
|
|
else
|
|
resolve(res);
|
|
}).catch(error => reject(error))
|
|
})
|
|
},
|
|
sendToken: function(privKey, amount, message = "", receiverID = floGlobals.adminID, token = 'rupee') {
|
|
return new Promise((resolve, reject) => {
|
|
let senderID = floCrypto.getFloID(privKey);
|
|
if (typeof amount !== "number" || amount <= 0)
|
|
return reject("Invalid amount");
|
|
this.getBalance(senderID, token).then(bal => {
|
|
if (amount > bal)
|
|
return reject("Insufficiant token balance");
|
|
floBlockchainAPI.writeData(senderID, `send ${amount} ${token}# ${message}`, privKey, receiverID)
|
|
.then(txid => resolve(txid))
|
|
.catch(error => reject(error))
|
|
}).catch(error => reject(error))
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function getRates() {
|
|
return new Promise((resolve, reject) => {
|
|
getRates.FLO_USD().then(FLO_rate => {
|
|
getRates.USD_INR().then(INR_rate => {
|
|
net_FLO_price = FLO_rate * INR_rate;
|
|
console.debug('Rates:', FLO_rate, INR_rate, net_FLO_price);
|
|
resolve(net_FLO_price);
|
|
}).catch(error => reject(error))
|
|
}).catch(error => reject(error))
|
|
});
|
|
}
|
|
|
|
getRates.FLO_USD = function() {
|
|
return new Promise((resolve, reject) => {
|
|
fetch('https://api.coinlore.net/api/ticker/?id=67').then(response => {
|
|
if (response.ok) {
|
|
response.json()
|
|
.then(result => resolve(result[0].price_usd))
|
|
.catch(error => reject(error));
|
|
} else
|
|
reject(response.status);
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
getRates.USD_INR = function() {
|
|
return new Promise((resolve, reject) => {
|
|
fetch('https://api.exchangerate-api.com/v4/latest/usd').then(response => {
|
|
if (response.ok) {
|
|
response.json()
|
|
.then(result => resolve(result.rates['INR']))
|
|
.catch(error => reject(error));
|
|
} else
|
|
reject(response.status);
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function addSellOrder(floID, quantity, min_price) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!floID || !floCrypto.validateAddr(floID))
|
|
return reject(INVALID("Invalid FLO ID"));
|
|
else if (typeof quantity !== "number" || quantity <= 0)
|
|
return reject(INVALID(`Invalid quantity (${quantity})`));
|
|
else if (typeof min_price !== "number" || min_price <= 0)
|
|
return reject(INVALID(`Invalid min_price (${min_price})`));
|
|
DB.query("SELECT SUM(quantity) as total FROM Vault WHERE floID=?", [floID]).then(result => {
|
|
let total = result.pop()["total"] || 0;
|
|
if (total < quantity)
|
|
return reject(INVALID("Insufficient FLO"));
|
|
DB.query("SELECT SUM(quantity) as locked FROM SellOrder WHERE floID=?", [floID]).then(result => {
|
|
let locked = result.pop()["locked"] || 0;
|
|
let available = total - locked;
|
|
console.debug(total, locked, available);
|
|
if (available < quantity)
|
|
return reject(INVALID("Insufficient FLO (Some FLO are locked in another sell order)"));
|
|
DB.query("INSERT INTO SellOrder(floID, quantity, minPrice) VALUES (?, ?, ?)", [floID, quantity, min_price])
|
|
.then(result => resolve("Added SellOrder to DB"))
|
|
.catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function addBuyOrder(floID, quantity, max_price) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!floID || !floCrypto.validateAddr(floID))
|
|
return reject(INVALID("Invalid FLO ID"));
|
|
else if (typeof quantity !== "number" || quantity <= 0)
|
|
return reject(INVALID(`Invalid quantity (${quantity})`));
|
|
else if (typeof max_price !== "number" || max_price <= 0)
|
|
return reject(INVALID(`Invalid max_price (${max_price})`));
|
|
DB.query("SELECT rupeeBalance FROM Users WHERE floID=?", [floID]).then(result => {
|
|
if (result.length < 1)
|
|
return reject(INVALID("FLO ID not registered"));
|
|
let total = result.pop()["rupeeBalance"];
|
|
if (total < quantity * max_price)
|
|
return reject(INVALID("Insufficient Rupee balance"));
|
|
DB.query("SELECT SUM(maxPrice * quantity) as locked FROM BuyOrder WHERE floID=?", [floID]).then(result => {
|
|
let locked = result.pop()["locked"] || 0;
|
|
let available = total - locked;
|
|
console.debug(total, locked, available);
|
|
if (available < quantity * max_price)
|
|
return reject(INVALID("Insufficient Rupee balance (Some rupee tokens are locked in another buy order)"));
|
|
DB.query("INSERT INTO BuyOrder(floID, quantity, maxPrice) VALUES (?, ?, ?)", [floID, quantity, max_price])
|
|
.then(result => resolve("Added BuyOrder to DB"))
|
|
.catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function cancelOrder(type, id, floID) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!floID || !floCrypto.validateAddr(floID))
|
|
return reject(INVALID("Invalid FLO ID"));
|
|
let tableName;
|
|
if (type === "buy")
|
|
tableName = "BuyOrder";
|
|
else if (type === "sell")
|
|
tableName = "SellOrder";
|
|
else
|
|
return reject(INVALID("Invalid Order type! Order type must be buy (or) sell"));
|
|
DB.query(`SELECT floID FROM ${tableName} WHERE id=?`, [id]).then(result => {
|
|
if (result.length < 1)
|
|
return reject(INVALID("Order not found!"));
|
|
else if (result[0].floID !== floID)
|
|
return reject(INVALID("Order doesnt belong to the current user"));
|
|
//Delete the order
|
|
DB.query(`DELETE FROM ${tableName} WHERE id=?`, [id])
|
|
.then(result => resolve(tableName + "#" + id + " cancelled successfully"))
|
|
.catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function matchBuyAndSell() {
|
|
let cur_price = net_FLO_price;
|
|
//get the best buyer
|
|
getBestBuyer(cur_price).then(buyer_best => {
|
|
//get the best seller
|
|
getBestSeller(buyer_best.quantity, cur_price).then(result => {
|
|
let seller_best = result.sellOrder,
|
|
txQueries = result.txQueries;
|
|
console.debug("Sell:", seller_best.id, "Buy:", buyer_best.id);
|
|
|
|
//process the Txn
|
|
var tx_quantity;
|
|
if (seller_best.quantity > buyer_best.quantity)
|
|
tx_quantity = processBuyOrder(seller_best, buyer_best, txQueries);
|
|
else if (seller_best.quantity < buyer_best.quantity)
|
|
tx_quantity = processSellOrder(seller_best, buyer_best, txQueries);
|
|
else
|
|
tx_quantity = processBuyAndSellOrder(seller_best, buyer_best, txQueries);
|
|
updateBalance(seller_best, buyer_best, txQueries, cur_price, tx_quantity);
|
|
//process txn query in SQL
|
|
DB.transaction(txQueries).then(results => {
|
|
console.log(`Transaction was successful! BuyOrder:${buyer_best.id}| SellOrder:${seller_best.id}`);
|
|
//Since a tx was successful, match again
|
|
matchBuyAndSell();
|
|
}).catch(error => console.error(error));
|
|
}).catch(error => console.error(error));
|
|
}).catch(error => console.error(error));
|
|
}
|
|
|
|
function getBestBuyer(cur_price, n = 0) {
|
|
return new Promise((resolve, reject) => {
|
|
DB.query("SELECT * FROM BuyOrder WHERE maxPrice >= ? ORDER BY time_placed LIMIT ?,1", [cur_price, n]).then(result => {
|
|
let buyOrder = result.shift();
|
|
if (!buyOrder)
|
|
return reject("No valid buyers available");
|
|
DB.query("SELECT rupeeBalance as bal FROM Users WHERE floID=?", [buyOrder.floID]).then(result => {
|
|
if (result[0].bal < cur_price * buyOrder.quantity) {
|
|
//This should not happen unless a buy order is placed when user doesnt have enough rupee balance
|
|
console.warn(`Buy order ${buyOrder.id} is active, but rupee# is insufficient`);
|
|
getBestBuyer(cur_price, n + 1)
|
|
.then(result => resolve(result))
|
|
.catch(error => reject(error));
|
|
} else
|
|
resolve(buyOrder);
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function getBestSeller(maxQuantity, cur_price, n = 0) {
|
|
return new Promise((resolve, reject) => {
|
|
//TODO: Add order conditions for priority.
|
|
DB.query("SELECT * FROM SellOrder WHERE minPrice <=? ORDER BY time_placed LIMIT ?,1", [cur_price, n]).then(result => {
|
|
let sellOrder = result.shift();
|
|
if (!sellOrder)
|
|
return reject("No valid sellers available");
|
|
DB.query("SELECT id, quantity, base FROM Vault WHERE floID=? ORDER BY base", [sellOrder.floID]).then(result => {
|
|
let rem = Math.min(sellOrder.quantity, maxQuantity),
|
|
sell_base = 0,
|
|
base_quantity = 0,
|
|
txQueries = [];
|
|
for (let i = 0; i < result.length && rem > 0; i++) {
|
|
if (rem < result[i].quantity) {
|
|
txQueries.push(["UPDATE Vault SET quantity=quantity-? WHERE id=?", [rem, result[i].id]]);
|
|
if (result[i].base) {
|
|
sell_base += (rem * result[i].base);
|
|
base_quantity += rem
|
|
}
|
|
rem = 0;
|
|
} else {
|
|
txQueries.push(["DELETE FROM Vault WHERE id=?", [result[i].id]]);
|
|
if (result[i].base) {
|
|
sell_base += (result[i].quantity * result[i].base);
|
|
base_quantity += result[i].quantity
|
|
}
|
|
rem -= result[i].quantity;
|
|
}
|
|
}
|
|
if (base_quantity)
|
|
sell_base = sell_base / base_quantity;
|
|
if (rem > 0 || sell_base > cur_price) {
|
|
//1st condition (rem>0) should not happen (sell order placement was success when insufficient FLO).
|
|
if (rem > 0)
|
|
console.warn(`Sell order ${sellOrder.id} is active, but FLO is insufficient`);
|
|
getBestSeller(maxQuantity, cur_price, n + 1)
|
|
.then(result => resolve(result))
|
|
.catch(error => reject(error));
|
|
} else
|
|
resolve({
|
|
sellOrder,
|
|
txQueries
|
|
});
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function processBuyOrder(seller_best, buyer_best, txQueries) {
|
|
let quantity = buyer_best.quantity;
|
|
//Buy order is completed, sell order is partially done.
|
|
txQueries.push(["DELETE FROM BuyOrder WHERE id=?", [buyer_best.id]]);
|
|
txQueries.push(["UPDATE SellOrder SET quantity=quantity-? WHERE id=?", [quantity, seller_best.id]]);
|
|
return quantity;
|
|
}
|
|
|
|
function processSellOrder(seller_best, buyer_best, txQueries) {
|
|
let quantity = seller_best.quantity;
|
|
//Sell order is completed, buy order is partially done.
|
|
txQueries.push(["DELETE FROM SellOrder WHERE id=?", [seller_best.id]]);
|
|
txQueries.push(["UPDATE BuyOrder SET quantity=quantity-? WHERE id=?", [quantity, buyer_best.id]]);
|
|
return quantity;
|
|
}
|
|
|
|
function processBuyAndSellOrder(seller_best, buyer_best, txQueries) {
|
|
//Both sell order and buy order is completed
|
|
txQueries.push(["DELETE FROM SellOrder WHERE id=?", [seller_best.id]]);
|
|
txQueries.push(["DELETE FROM BuyOrder WHERE id=?", [buyer_best.id]]);
|
|
return seller_best.quantity;
|
|
}
|
|
|
|
function updateBalance(seller_best, buyer_best, txQueries, cur_price, quantity) {
|
|
//Update rupee balance for seller and buyer
|
|
let totalAmount = cur_price * quantity;
|
|
txQueries.push(["UPDATE Users SET rupeeBalance=rupeeBalance+? WHERE floID=?", [totalAmount, seller_best.floID]]);
|
|
txQueries.push(["UPDATE Users SET rupeeBalance=rupeeBalance-? WHERE floID=?", [totalAmount, buyer_best.floID]]);
|
|
//Add coins to Buyer
|
|
txQueries.push(["INSERT INTO Vault(floID, base, quantity) VALUES (?, ?, ?)", [buyer_best.floID, cur_price, quantity]])
|
|
//Record transaction
|
|
txQueries.push(["INSERT INTO Transactions (seller, buyer, quantity, unitValue) VALUES (?, ?, ?, ?)", [seller_best.floID, buyer_best.floID, quantity, cur_price]]);
|
|
return;
|
|
}
|
|
|
|
function getAccountDetails(floID) {
|
|
return new Promise((resolve, reject) => {
|
|
let select = [];
|
|
select.push(["rupeeBalance", "Users"]);
|
|
select.push(["base, quantity", "Vault"]);
|
|
select.push(["id, quantity, minPrice, time_placed", "SellOrder"]);
|
|
select.push(["id, quantity, maxPrice, time_placed", "BuyOrder"]);
|
|
let promises = select.map(a => DB.query("SELECT " + a[0] + " FROM " + a[1] + " WHERE floID=?", [floID]));
|
|
Promise.allSettled(promises).then(results => {
|
|
let response = {
|
|
floID: floID,
|
|
time: Date.now()
|
|
};
|
|
results.forEach((a, i) => {
|
|
if (a.status === "rejected")
|
|
console.error(a.reason);
|
|
else
|
|
switch (i) {
|
|
case 0:
|
|
response.rupee_total = a.value[0].rupeeBalance;
|
|
break;
|
|
case 1:
|
|
response.coins = a.value;
|
|
break;
|
|
case 2:
|
|
response.sellOrders = a.value;
|
|
break;
|
|
case 3:
|
|
response.buyOrders = a.value;
|
|
break;
|
|
}
|
|
});
|
|
DB.query("SELECT * FROM Transactions WHERE seller=? OR buyer=?", [floID, floID])
|
|
.then(result => response.transactions = result)
|
|
.catch(error => console.error(error))
|
|
.finally(_ => resolve(response));
|
|
});
|
|
});
|
|
}
|
|
|
|
function depositCoins(floID, txid) {
|
|
return new Promise((resolve, reject) => {
|
|
DB.query("SELECT status FROM inputFLO WHERE txid=? AND floID=?", [txid, floID]).then(result => {
|
|
if (result.length) {
|
|
switch (result[0].status) {
|
|
case "PENDING":
|
|
return reject(INVALID("Transaction already in process"));
|
|
case "REJECTED":
|
|
return reject(INVALID("Transaction already rejected"));
|
|
case "SUCCESS":
|
|
return reject(INVALID("Transaction already used to add coins"));
|
|
}
|
|
} else
|
|
DB.query("INSERT INTO inputFLO(txid, floID, status) VALUES (?, ?, ?)", [txid, floID, "PENDING"])
|
|
.then(result => resolve("Deposit request in process"))
|
|
.catch(error => reject(error));
|
|
}).catch(error => reject(error))
|
|
});
|
|
}
|
|
|
|
function confirmDepositFLO() {
|
|
DB.query("SELECT id, floID, txid FROM inputFLO WHERE status=?", ["PENDING"]).then(results => {
|
|
results.forEach(req => {
|
|
confirmDepositFLO.checkTx(req.floID, req.txid).then(amount => {
|
|
let txQueries = [];
|
|
txQueries.push("INSERT INTO Vault(floID, quantity) VALUES (?, ?)", [floID, amount]);
|
|
txQueries.push("UPDATE inputFLO SET status=?, amount=? WHERE id=?", ["SUCCESS", amount, req.id]);
|
|
DB.transaction(txQueries)
|
|
.then(result => console.debug("FLO deposited for ", floID))
|
|
.catch(error => console.error(error))
|
|
}).catch(error => {
|
|
if (!Array.isArray(error))
|
|
console.error(error);
|
|
else if (error[0])
|
|
DB.query("UPDATE inputFLO SET status=? WHERE id=?", ["REJECTED", req.id])
|
|
.then(_ => null).catch(error => console.error(error));
|
|
});
|
|
})
|
|
}).catch(error => console.error(error))
|
|
}
|
|
|
|
confirmDepositFLO.checkTx = function(sender, txid) {
|
|
return new Promise((resolve, reject) => {
|
|
const receiver = globals.myFloID; //receiver should be market's floID (ie, adminID)
|
|
floBlockchainAPI.getTx(txid).then(tx => {
|
|
let vin_sender = tx.vin.filter(v => v.addr === sender).length
|
|
if (!vin_sender.length)
|
|
return reject([true, "Transaction not sent by the sender"]);
|
|
if (vin_sender.length !== tx.vin.length)
|
|
return reject([true, "Transaction input containes other floIDs"]);
|
|
if (!tx.blockheight)
|
|
return reject([false, "Transaction not included in any block yet"]);
|
|
if (!tx.confirmations)
|
|
return reject([false, "Transaction not confirmed yet"]);
|
|
let amount = tx.vout.reduce(v => v.scriptPubKey.addresses[0] === receiver ? a + v.value : a, 0);
|
|
if (amount == 0)
|
|
return reject([true, "Transaction receiver is not market ID"]);
|
|
else
|
|
resolve(amount);
|
|
}).catch(error => reject([false, error]))
|
|
})
|
|
}
|
|
|
|
function withdrawCoins(floID, amount) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!floID || !floCrypto.validateAddr(floID))
|
|
return reject(INVALID("Invalid FLO ID"));
|
|
else if (typeof amount !== "number" || amount <= 0)
|
|
return reject(INVALID(`Invalid amount (${amount})`));
|
|
DB.query("SELECT SUM(quantity) as total FROM Vault WHERE floID=?", [floID]).then(result => {
|
|
let total = result.pop()["total"] || 0;
|
|
if (total < amount)
|
|
return reject(INVALID("Insufficient FLO"));
|
|
DB.query("SELECT SUM(quantity) as locked FROM SellOrder WHERE floID=?", [floID]).then(result => {
|
|
let locked = result.pop()["locked"] || 0;
|
|
let available = total - locked;
|
|
if (available < amount)
|
|
return reject(INVALID("Insufficient FLO (Some FLO are locked in sell orders)"));
|
|
DB.query("SELECT id, quantity, base FROM Vault WHERE floID=? ORDER BY locktime", [floID]).then(coins => {
|
|
let rem = amount,
|
|
txQueries = [];
|
|
for (let i = 0; i < coins.length && rem > 0; i++) {
|
|
if (rem < coins[i].quantity) {
|
|
txQueries.push(["UPDATE Vault SET quantity=quantity-? WHERE id=?", [rem, coins[i].id]]);
|
|
rem = 0;
|
|
} else {
|
|
txQueries.push(["DELETE FROM Vault WHERE id=?", [coins[i].id]]);
|
|
rem -= result[i].quantity;
|
|
}
|
|
}
|
|
if (rem > 0) //should not happen as the total and net is checked already
|
|
return reject(INVALID("Insufficient FLO"));
|
|
DB.transaction(txQueries).then(result => {
|
|
//Send FLO to user via blockchain API
|
|
floBlockchainAPI.sendTx(global.myFloID, floID, amount, global.myPrivKey, 'Withdraw FLO Coins from Market').then(result => {
|
|
let txid = result.txid.result;
|
|
if (!txid || result.txid.error)
|
|
throw Error("Transaction not successful");
|
|
//Transaction was successful, Add in DB
|
|
DB.query("INSERT INTO outputFLO (floID, amount, txid, status) VALUES (?, ?, ?, ?)", [floID, amount, txid, "WAITING_CONFIRMATION"])
|
|
.then(_ => null).catch(error => console.error(error))
|
|
.finally(_ => resolve("Withdrawal was successful"));
|
|
}).catch(error => {
|
|
DB.query("INSERT INTO outputFLO (floID, amount, txid, status) VALUES (?, ?, ?, ?)", [floID, amount, txid, "PENDING"])
|
|
.then(_ => null).catch(error => console.error(error))
|
|
.finally(_ => resolve("Withdrawal request is in process"));
|
|
});
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function retryWithdrawalFLO() {
|
|
DB.query("SELECT id, floID, amount FROM outputFLO WHERE status=?", ["PENDING"]).then(results => {
|
|
results.forEach(req => {
|
|
floBlockchainAPI.sendTx(global.myFloID, req.floID, req.amount, global.myPrivKey, 'Withdraw FLO Coins from Market').then(result => {
|
|
let txid = result.txid.result;
|
|
if (!txid || result.txid.error) {
|
|
console.error(result);
|
|
return;
|
|
}
|
|
//Transaction was successful, Add in DB
|
|
DB.query("UPDATE outputFLO SET status=? WHERE id=?", ["WAITING_CONFIRMATION", req.id])
|
|
.then(_ => null).catch(error => console.error(error));
|
|
}).catch(error => console.error(error));
|
|
})
|
|
}).catch(error => reject(error));
|
|
}
|
|
|
|
function confirmWithdrawalFLO() {
|
|
DB.query("SELECT id, floID, txid FROM outputFLO WHERE status=?", ["WAITING_CONFIRMATION"]).then(results => {
|
|
results.forEach(req => {
|
|
floBlockchainAPI.getTx(req.txid).then(tx => {
|
|
if (!tx.blockheight || !tx.confirmations) //Still not confirmed
|
|
return;
|
|
DB.query("UPDATE outputFLO SET status=? WHERE id=?", ["SUCCESS", req.id])
|
|
.then(result => console.debug("FLO withdrawed for ", req.floID))
|
|
.catch(error => console.error(error))
|
|
}).catch(error => console.error(error));
|
|
})
|
|
}).catch(error => console.error(error));
|
|
}
|
|
|
|
function depositTokens(floID, txid) {
|
|
return new Promise((resolve, reject) => {
|
|
DB.query("SELECT status FROM inputRupee WHERE txid=? AND floID=?", [txid, floID]).then(result => {
|
|
if (result.length) {
|
|
switch (result[0].status) {
|
|
case "PENDING":
|
|
return reject(INVALID("Transaction already in process"));
|
|
case "REJECTED":
|
|
return reject(INVALID("Transaction already rejected"));
|
|
case "SUCCESS":
|
|
return reject(INVALID("Transaction already used to add tokens"));
|
|
}
|
|
} else
|
|
DB.query("INSERT INTO inputRupee(txid, floID, status) VALUES (?, ?, ?)", [txid, floID, "PENDING"])
|
|
.then(result => resolve("Deposit request in process"))
|
|
.catch(error => reject(error));
|
|
}).catch(error => reject(error))
|
|
});
|
|
}
|
|
|
|
function confirmDepositRupee() {
|
|
DB.query("SELECT id, floID, txid FROM inputRupee WHERE status=?", ["PENDING"]).then(results => {
|
|
results.forEach(req => {
|
|
confirmDepositRupee.checkTx(req.floID, req.txid).then(amounts => {
|
|
DB.query("SELECT id FROM inputFLO where floID=? AND txid=?").then(result => {
|
|
let txQueries = [],
|
|
amount_rupee = amounts[0];
|
|
//Add the FLO balance if necessary
|
|
if (!result.length) {
|
|
let amount_flo = amounts[1];
|
|
txQueries.push("INSERT INTO Vault(floID, quantity) VALUES (?, ?)", [req.floID, amount_flo]);
|
|
txQueries.push("INSERT INTO inputFLO(txid, floID, status) VALUES (?, ?, ?)", [req.txid, req.floID, "SUCCESS"]);
|
|
}
|
|
txQueries.push("UPDATE inputRupee SET status=? WHERE id=?", ["SUCCESS", req.id]);
|
|
txQueries.push("UPDATE Users SET rupeeBalance=rupeeBalance+? WHERE floID=?", [amount_rupee, req.floID]);
|
|
DB.transaction(txQueries)
|
|
.then(result => console.debug("Rupee deposited for ", req.floID))
|
|
.catch(error => console.error(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => {
|
|
if (!Array.isArray(error))
|
|
console.error(error);
|
|
else if (error[0])
|
|
DB.query("UPDATE inputRupee SET status=? WHERE id=?", ["REJECTED", req.id])
|
|
.then(_ => null).catch(error => console.error(error));
|
|
});
|
|
})
|
|
}).catch(error => console.error(error))
|
|
}
|
|
|
|
confirmDepositRupee.checkTx = function(sender, txid) {
|
|
return new Promise((resolve, reject) => {
|
|
const receiver = globals.myFloID; //receiver should be market's floID (ie, adminID)
|
|
tokenAPI.getTx(txid).then(tx => {
|
|
if (tx.parsedFloData.type !== "transfer")
|
|
return reject([true, "Transaction type not 'transfer'"]);
|
|
else if (tx.parsedFloData.transferType !== "token")
|
|
return reject([true, "Transaction transfer is not 'token'"]);
|
|
else if (tx.parsedFloData.tokenIdentification !== "rupee")
|
|
return reject([true, "Transaction token is not 'rupee'"]);
|
|
var amount_rupee = tx.parsedFloData.tokenAmount;
|
|
let vin_sender = tx.transactionDetails.vin.filter(v => v.addr === sender).length
|
|
if (!vin_sender.length)
|
|
return reject([true, "Transaction not sent by the sender"]);
|
|
let amount_flo = tx.transactionDetails.vout.reduce(v => v.scriptPubKey.addresses[0] === receiver ? a + v.value : a, 0);
|
|
if (amount_flo == 0)
|
|
return reject([true, "Transaction receiver is not market ID"]);
|
|
else
|
|
resolve([amount_rupee, amount_flo]);
|
|
}).catch(error => reject([false, error]))
|
|
})
|
|
}
|
|
|
|
function withdrawTokens(floID, amount) {
|
|
return new Promise((resolve, reject) => {
|
|
if (!floID || !floCrypto.validateAddr(floID))
|
|
return reject(INVALID("Invalid FLO ID"));
|
|
else if (typeof amount !== "number" || amount <= 0)
|
|
return reject(INVALID(`Invalid amount (${amount})`));
|
|
DB.query("SELECT SUM(quantity) as total FROM Vault WHERE floID=?", [floID]).then(result => {
|
|
let required_flo = floGlobals.sendAmt + floGlobals.fee,
|
|
total = result.pop()["total"] || 0;
|
|
if (total < required_flo)
|
|
return reject(INVALID(`Insufficient FLO! Required ${required_flo} FLO to withdraw tokens`));
|
|
DB.query("SELECT SUM(quantity) as locked FROM SellOrder WHERE floID=?", [floID]).then(result => {
|
|
let locked = result.pop()["locked"] || 0;
|
|
let available = total - locked;
|
|
if (available < amount)
|
|
return reject(INVALID(`Insufficient FLO (Some FLO are locked in sell orders)! Required ${required_flo} FLO to withdraw tokens`));
|
|
DB.query("SELECT rupeeBalance FROM Users WHERE floID=?", [floID]).then(result => {
|
|
if (result.length < 1)
|
|
return reject(INVALID(`FLO_ID: ${floID} not registered`));
|
|
if (result[0].rupeeBalance < amount)
|
|
return reject(INVALID('Insufficient Rupee balance'));
|
|
DB.query("SELECT id, quantity, base FROM Vault WHERE floID=? ORDER BY locktime", [floID]).then(coins => {
|
|
let rem = required_flo,
|
|
txQueries = [];
|
|
for (let i = 0; i < coins.length && rem > 0; i++) {
|
|
if (rem < coins[i].quantity) {
|
|
txQueries.push(["UPDATE Vault SET quantity=quantity-? WHERE id=?", [rem, coins[i].id]]);
|
|
rem = 0;
|
|
} else {
|
|
txQueries.push(["DELETE FROM Vault WHERE id=?", [coins[i].id]]);
|
|
rem -= result[i].quantity;
|
|
}
|
|
}
|
|
if (rem > 0) //should not happen as the total and net is checked already
|
|
return reject(INVALID("Insufficient FLO"));
|
|
txQueries.push(["UPDATE Users SET rupeeBalance=rupeeBalance-? WHERE floID=?", [amount, floID]]);
|
|
|
|
DB.transaction(txQueries).then(result => {
|
|
//Send FLO to user via blockchain API
|
|
tokenAPI.sendToken(global.myPrivKey, amount, '(withdrawal from market)', floID).then(result => {
|
|
let txid = result.txid.result;
|
|
if (!txid || result.txid.error)
|
|
throw Error("Transaction not successful");
|
|
//Transaction was successful, Add in DB
|
|
DB.query("INSERT INTO outputRupee (floID, amount, txid, status) VALUES (?, ?, ?, ?)", [floID, amount, txid, "WAITING_CONFIRMATION"])
|
|
.then(_ => null).catch(error => console.error(error))
|
|
.finally(_ => resolve("Withdrawal was successful"));
|
|
}).catch(error => {
|
|
DB.query("INSERT INTO outputRupee (floID, amount, txid, status) VALUES (?, ?, ?, ?)", [floID, amount, txid, "PENDING"])
|
|
.then(_ => null).catch(error => console.error(error))
|
|
.finally(_ => resolve("Withdrawal request is in process"));
|
|
});
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
}).catch(error => reject(error));
|
|
});
|
|
}
|
|
|
|
function retryWithdrawalRupee() {
|
|
DB.query("SELECT id, floID, amount FROM outputRupee WHERE status=?", ["PENDING"]).then(results => {
|
|
results.forEach(req => {
|
|
tokenAPI.sendToken(global.myPrivKey, req.amount, '(withdrawal from market)', req.floID).then(result => {
|
|
let txid = result.txid.result;
|
|
if (!txid || result.txid.error) {
|
|
console.error(result);
|
|
return;
|
|
}
|
|
//Transaction was successful, Add in DB
|
|
DB.query("UPDATE outputRupee SET status=? WHERE id=?", ["WAITING_CONFIRMATION", req.id])
|
|
.then(_ => null).catch(error => console.error(error));
|
|
}).catch(error => console.error(error));
|
|
});
|
|
}).catch(error => reject(error));
|
|
}
|
|
|
|
function confirmWithdrawalRupee() {
|
|
DB.query("SELECT id, floID, amount, txid FROM outputRupee WHERE status=?", ["WAITING_CONFIRMATION"]).then(results => {
|
|
results.forEach(req => {
|
|
tokenAPI.getTx(req.txid).then(tx => {
|
|
DB.query("UPDATE outputRupee SET status=? WHERE id=?", ["SUCCESS", req.id])
|
|
.then(result => console.debug("Rupee withdrawed for ", req.floID))
|
|
.catch(error => console.error(error));
|
|
}).catch(error => console.error(error));
|
|
})
|
|
}).catch(error => console.error(error));
|
|
}
|
|
|
|
function intervalFunction() {
|
|
let old_rate = net_FLO_price;
|
|
getRates().then(cur_rate => {
|
|
transactionReCheck();
|
|
matchBuyAndSell();
|
|
}).catch(error => console.error(error));
|
|
}
|
|
|
|
function transactionReCheck() {
|
|
confirmDepositFLO();
|
|
confirmDepositRupee();
|
|
retryWithdrawalFLO();
|
|
retryWithdrawalRupee();
|
|
confirmWithdrawalFLO();
|
|
confirmWithdrawalRupee();
|
|
}
|
|
|
|
intervalFunction();
|
|
|
|
let refresher = setInterval(intervalFunction, REFRESH_INTERVAL);
|
|
|
|
module.exports = {
|
|
addBuyOrder,
|
|
addSellOrder,
|
|
cancelOrder,
|
|
getAccountDetails,
|
|
depositCoins,
|
|
withdrawCoins,
|
|
depositTokens,
|
|
withdrawTokens,
|
|
set DB(db) {
|
|
DB = db;
|
|
}
|
|
}; |