├── views
    ├── qrtest.html
    ├── index.ejs
    ├── signup.ejs
    ├── profile.ejs
    ├── login.ejs
    ├── withdraw.ejs
    └── deposit.ejs
├── config
    ├── database.js
    ├── bchconfig.js
    ├── ethereum.js
    └── passport.js
├── .gitattributes
├── README.md
├── package.json
├── scripts
    ├── create_bchhdprivatekey.js
    └── create_database.js
├── server.js
├── .gitignore
├── service
    ├── keystorebch.js
    ├── keystoreeth.js
    ├── db_service.js
    └── bitcoincashrpc.js
└── app
    ├── routes.js
    ├── eth_transactions.js
    └── bch_transactions.js


/views/qrtest.html:
--------------------------------------------------------------------------------
 1 | <script src="../node_modules/qrcode/build/qrcode.min.js"></script>
 2 | <canvas id="qrcodec"></canvas>
 3 | 
 4 | 
 5 | <script>
 6 |     qrcodelib.toCanvas(document.getElementById('qrcodec'), "your eth address", function (error) {
 7 |         if (error) console.error(error)
 8 |         console.log('qrcode successfully created');
 9 |     });
10 | 
11 | 
12 | </script>


--------------------------------------------------------------------------------
/config/database.js:
--------------------------------------------------------------------------------
 1 | // config/database.js
 2 | module.exports = {
 3 |     'connection': {
 4 |         'host': 'localhost',
 5 |         'user': 'root',
 6 |         'password': '@x6iyLxk_2vH'
 7 |     },
 8 | 	'database': 'my_schema',
 9 |     'users_table': 'users',
10 |     'ethereum_transaction':'eth_transaction',
11 |     'bch_transaction':'bch_transaction',
12 |     "eth_withdraw_log":'eth_withdraw_log',
13 |     "bch_withdraw_log":'bch_withdraw_log'
14 | };


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/config/bchconfig.js:
--------------------------------------------------------------------------------
 1 | // configurations for BCH deposit service
 2 | var bitcorecash = require('bitcoincashjs');
 3 | Networks = bitcorecash.Networks;
 4 | Networks.enableRegtest();
 5 | 
 6 | module.exports = {
 7 |     'network': Networks.testnet,
 8 |     'host': 'localhost',
 9 |     'username': 'admin',
10 |     'password':'password',
11 |     'port': 8332,
12 |     'minStartBlock': 0, // When scan the block, the starting point
13 |     'minConfirmation':20,
14 |     "coinsPerBCH":1000,
15 |     'withdrawSourceHDPath': ['m/0\'/1\'/0\''],//The address associate with this HDpath is mvpVLHH3UmACHJ1JV6tcneZFB5pqpvVs9j.
16 |     'minTxFee':0.001
17 | };


--------------------------------------------------------------------------------
/config/ethereum.js:
--------------------------------------------------------------------------------
 1 | // configurations for Ethereum deposit service
 2 | module.exports = {
 3 |     'host': 'http://localhost:8545', //Ip address and port of the ethereum node service
 4 |     'minMinedRequirement' : 20, //a transaction will be deposited only after N mined blocks.
 5 |     'minStartBlock': 44984, // When scan the block, the starting point
 6 |     'WeisPerCoin': 1000000000000000,
 7 |     'ethDepositCheckInterval': 10000, // In milliseconds
 8 |     'keyStorePassword':'0.8487677677962937',
 9 |     'withdrawSourceAccount': '0xafdf17bcb4b9a99ab2fdf30b6f0d62b59ea42bdd'
10 |     //withdrawsouce in Jeremy's regtest network is: mvpVLHH3UmACHJ1JV6tcneZFB5pqpvVs9j
11 | };


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Complete Guide to Coin and Cryptocurrecny Exchange Demo
 2 | 
 3 | This is an onging project.
 4 | 
 5 | Current version database is ported to MySQL
 6 | 
 7 | We will be using Passport to authenticate users locally, 
 8 | 
 9 | ## Instructions
10 | 
11 | If you would like to download the code and try it for yourself:
12 | 
13 | 1. Clone the repo: `git clone git@github.com:JeremywangCN/coin-cryptocurrency-exchange.git`
14 | 1. Install packages: `npm install`
15 | 1. Edit the database configuration: `config/database.js`
16 | 1. Edit the ethereum configuration: 'config/ethereum.js'
17 | 1. Create the database schema: `node scripts/create_database.js`
18 | 1. Create a BCH HDkey for demo: `node scripts/create_bchhdprivatekey.js`
19 | 1. Launch: `node server.js`
20 | 1. Visit in your browser at: `http://localhost:8080`
21 | 
22 | Licence: 1
23 | 


--------------------------------------------------------------------------------
/views/index.ejs:
--------------------------------------------------------------------------------
 1 | <!-- views/index.ejs -->
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | 	<title>Coins and Cryptocurrency Exchange</title>
 6 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css"> <!-- load bootstrap css -->
 7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css"> <!-- load fontawesome -->
 8 | 	<style>
 9 | 		body 		{ padding-top:80px; }
10 | 	</style>
11 | </head>
12 | <body>
13 |     <div class="container">
14 |         <div class="jumbotron text-center">
15 |             <h1><span class="fa fa-lock"></span> Coins and Cryptocurrency Exchange</h1>
16 | 
17 |             <p>Login or Register with:</p>
18 | 
19 |             <a href="/login" class="btn btn-default"><span class="fa fa-user"></span> Local Login</a>
20 |             <a href="/signup" class="btn btn-default"><span class="fa fa-user"></span> Local Signup</a>
21 |         </div>
22 |     </div>
23 | 
24 | </body>
25 | </html>


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "node-authentication",
 3 |   "main": "server.js",
 4 |   "scripts": {
 5 |     "start": "node ./server"
 6 |   },
 7 |   "dependencies": {
 8 |     "axios": "^0.18.0",
 9 |     "bchaddrjs": "^0.2.1",
10 |     "bcrypt-nodejs": "0.0.3",
11 |     "npm-address-translator": "^1.0.4",
12 |     "qr-image": "^3.2.0",
13 |     "bitcoincashjs": "^0.1.10",
14 |     "bitcore-lib": "^0.15.0",
15 |     "body-parser": "^1.13.1",
16 |     "connect-flash": "^0.1.1",
17 |     "cookie-parser": "^1.3.5",
18 |     "ejs": "^2.3.2",
19 |     "eth-lightwallet": "^3.0.1",
20 |     "express": "^4.13.0",
21 |     "express-session": "^1.11.3",
22 |     "hooked-web3-provider": "^1.0.0",
23 |     "morgan": "^1.6.0",
24 |     "mysql": "^2.7.0",
25 |     "passport": "^0.2.2",
26 |     "passport-local": "^1.0.0",
27 |     "qrcode": "^1.2.0",
28 |     "web3": "^0.16.0"
29 |   },
30 |   "repository": {
31 |     "type": "git",
32 |     "url": "git://github.com/JeremywangCN/coin-cryptocurrency-exchange.git"
33 |   }
34 | }
35 | 


--------------------------------------------------------------------------------
/scripts/create_bchhdprivatekey.js:
--------------------------------------------------------------------------------
 1 | // This script creates a BIP 32 HD Private Key and save as a file to the server.
 2 | 
 3 | var bitcorecash = require('bitcoincashjs');
 4 | var HDPrivateKey = bitcorecash.HDPrivateKey;
 5 | 
 6 | var hdPrivateKey = new HDPrivateKey();
 7 | var hdPublicKey = hdPrivateKey.hdPublicKey;
 8 | var publickeyString = hdPublicKey.toString();
 9 | var privatekeyString = hdPrivateKey.toString();
10 | 
11 | const fs = require('fs');
12 | fs.writeFile('./keystorebchprivate.txt', privatekeyString, function(err){
13 |     // throws an error, you could also catch it here
14 |     if (err) throw err;
15 | 
16 |     // success case, the file was saved
17 |     console.log('BCH Private key '+ hdPrivateKey.toString()+'was saved to keystorebch.txt!');
18 | 
19 | });
20 | fs.writeFile('./keystorebchpublic.txt', publickeyString, function(err){
21 |     // throws an error, you could also catch it here
22 |     if (err) throw err;
23 | 
24 |     // success case, the file was saved
25 |     console.log('BCH Public key '+ publickeyString+'was saved to keystorebch.txt!');
26 | 
27 | });
28 | 
29 | 


--------------------------------------------------------------------------------
/views/signup.ejs:
--------------------------------------------------------------------------------
 1 | <!-- views/signup.ejs -->
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | 	<title>Node Authentication</title>
 6 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css"> <!-- load bootstrap css -->
 7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css"> <!-- load fontawesome -->
 8 | 	<style>
 9 | 		body 		{ padding-top:80px; }
10 | 	</style>
11 | </head>
12 | <body>
13 | <div class="container">
14 | 
15 | <div class="col-sm-6 col-sm-offset-3">
16 | 
17 | 	<h1><span class="fa fa-sign-in"></span> Signup</h1>
18 | 
19 | 	<!-- show any messages that come back with authentication -->
20 | 	<% if (message.length > 0) { %>
21 | 		<div class="alert alert-danger"><%= message %></div>
22 | 	<% } %>
23 | 
24 | 	<!-- LOGIN FORM -->
25 | 	<form action="/signup" method="post">
26 | 		<div class="form-group">
27 | 			<label>Username</label>
28 | 			<input type="text" class="form-control" name="username">
29 | 		</div>
30 | 		<div class="form-group">
31 | 			<label>Password</label>
32 | 			<input type="password" class="form-control" name="password">
33 | 		</div>
34 | 
35 | 		<button type="submit" class="btn btn-warning btn-lg">Signup</button>
36 | 	</form>
37 | 
38 | 	<hr>
39 | 
40 | 	<p>Already have an account? <a href="/login">Login</a></p>
41 | 	<p>Or go <a href="/">home</a>.</p>
42 | 
43 | </div>
44 | 
45 | </div>
46 | </body>
47 | </html>
48 | 


--------------------------------------------------------------------------------
/views/profile.ejs:
--------------------------------------------------------------------------------
 1 | <!-- views/profile.ejs -->
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | 	<title>Coins and Cryptocurrency Exchange</title>
 6 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css">
 7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css">
 8 | 
 9 | 	<style>
10 | 		body 		{ padding-top:80px; word-wrap:break-word; }
11 | 	</style>
12 | </head>
13 | <body>
14 | <div class="container">
15 | 
16 | 	<div class="page-header text-center">
17 | 		<h1><span class="fa fa-bitcoin"></span> Profile Page</h1>
18 | 		<a href="/logout" class="btn btn-default btn-sm">Logout</a>
19 | 	</div>
20 | 
21 | 	<div class="row">
22 | 		<div class="col-sm-6">
23 | 			<div class="well">
24 | 				<h3><span class="fa fa-user"></span> <%= user.username %></h3>
25 | 
26 | 					<p>
27 | 						<strong>ID</strong>: <%= user.id %><br>
28 | 						<strong>Coin</strong>: <%= user.coin %><br>
29 | 						<strong>Ethereum (GWei)</strong>: <%= user.eth_value %><br>
30 | 						<strong>Bicoin Cash(Satoshi)</strong>: <%= user.bch_value %>
31 | 					</p>
32 | 
33 | 			</div>
34 | 
35 | 		</div>
36 | 
37 | 	</div>
38 | 	<div class="page-header text-center">
39 | 		<a href="/deposit" class="btn btn-default btn-sm">Deposit Coins</a>
40 | 	</div>
41 | 	<div class="page-header text-center">
42 | 		<a href="/withdraw" class="btn btn-default btn-sm">Withdraw Coins</a>
43 | 	</div>
44 | 	<script>
45 | //		document.write('out='+document.get)
46 | 	</script>
47 | 
48 | </div>
49 | 
50 | </body>
51 | </html>
52 | 


--------------------------------------------------------------------------------
/views/login.ejs:
--------------------------------------------------------------------------------
 1 | <!-- views/login.ejs -->
 2 | <!doctype html>
 3 | <html>
 4 | <head>
 5 | 	<title>Node Authentication</title>
 6 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css"> <!-- load bootstrap css -->
 7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css"> <!-- load fontawesome -->
 8 | 	<style>
 9 | 		body 		{ padding-top:80px; }
10 | 	</style>
11 | </head>
12 | <body>
13 |     <div class="container">
14 |         <div class="col-sm-6 col-sm-offset-3">
15 |             <h1><span class="fa fa-sign-in"></span> Login</h1>
16 | 
17 |             <!-- show any messages that come back with authentication -->
18 |             <% if (message.length > 0) { %>
19 |                 <div class="alert alert-danger"><%= message %></div>
20 |             <% } %>
21 | 
22 |             <!-- LOGIN FORM -->
23 |             <form action="/login" method="post">
24 |                 <div class="form-group">
25 |                     <label>Username</label>
26 |                     <input type="text" class="form-control" name="username">
27 |                 </div>
28 |                 <div class="form-group">
29 |                     <label>Password</label>
30 |                     <input type="password" class="form-control" name="password">
31 |                 </div>
32 |                 <div class="form-group">
33 |                     <label>Remember Me</label>
34 |                     <input type="checkbox" class="form-control" name="remember" value="yes">
35 |                 </div>
36 | 
37 |                 <button type="submit" class="btn btn-warning btn-lg">Login</button>
38 |             </form>
39 | 
40 |             <hr>
41 | 
42 |             <p>Need an account? <a href="/signup">Signup</a></p>
43 |             <p>Or go <a href="/">home</a>.</p>
44 |         </div>
45 |     </div>
46 | </body>
47 | </html>
48 | 


--------------------------------------------------------------------------------
/server.js:
--------------------------------------------------------------------------------
 1 | // server.js
 2 | 
 3 | // set up ======================================================================
 4 | // get all the tools we need
 5 | var express  = require('express');
 6 | var session  = require('express-session');
 7 | var cookieParser = require('cookie-parser');
 8 | var bodyParser = require('body-parser');
 9 | var morgan = require('morgan');
10 | var app      = express();
11 | var port     = process.env.PORT || 8080;
12 | var passport = require('passport');
13 | var flash    = require('connect-flash');
14 | var ethConfig = require('./config/ethereum');
15 | 
16 | app.use(express.static('public'));
17 | // Initiate Ethereum Keystore and Eth Web3 instance. Start to check node for new unrecorded transactions.
18 | var keystore = require('./service/keystoreeth');
19 | var Eth = require('./app/eth_transactions');
20 | keystore.init(function (ifSucceed,ksi) {
21 |     if(ifSucceed){
22 |         Eth.init();
23 |     }
24 | });
25 | 
26 | // Init BCH HD Public key and wallet accounts
27 | var BCH = require('./app/bch_transactions');
28 | var bchKeyUtils= require('./service/keystorebch');
29 | bchKeyUtils.init(function (err) {
30 |     if(err);
31 |     else
32 |         BCH.updateUnspentTx();
33 | });
34 | 
35 | BCH.initRecipientAddresses();
36 | 
37 | setInterval(function () {
38 |     Eth.checkBlockChainForMinedTxService();
39 |     BCH.checkBlockChainForDepositTx();
40 |     BCH.updateSubmittedWithdrawTxs();
41 | },ethConfig.ethDepositCheckInterval);
42 | 
43 | // configuration ===============================================================
44 | // connect to our database
45 | 
46 | require('./config/passport')(passport); // pass passport for configuration
47 | 
48 | 
49 | // set up our express application
50 | app.use(morgan('dev')); // log every request to the console
51 | app.use(cookieParser()); // read cookies (needed for auth)
52 | app.use(bodyParser.urlencoded({
53 | 	extended: true
54 | }));
55 | app.use(bodyParser.json());
56 | 
57 | app.set('view engine', 'ejs'); // set up ejs for templating
58 | 
59 | // required for passport
60 | app.use(session({
61 | 	secret: 'vidyapathaisalwaysrunning',
62 | 	resave: true,
63 | 	saveUninitialized: true
64 |  } )); // session secret
65 | app.use(passport.initialize());
66 | app.use(passport.session()); // persistent login sessions
67 | app.use(flash()); // use connect-flash for flash messages stored in session
68 | 
69 | 
70 | 
71 | // routes ======================================================================
72 | require('./app/routes.js')(app, passport); // load our routes and pass in our app and fully configured passport
73 | 
74 | // launch ======================================================================
75 | app.listen(port);
76 | console.log('The magic happens on port ' + port);


--------------------------------------------------------------------------------
/scripts/create_database.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var mysql = require('mysql');
 3 | var dbconfig = require('../config/database');
 4 | 
 5 | var connection = mysql.createConnection(dbconfig.connection);
 6 | 
 7 | connection.query('CREATE DATABASE ' + dbconfig.database);
 8 | 
 9 | connection.query('\
10 | CREATE TABLE `' + dbconfig.database + '`.`' + dbconfig.users_table + '` ( \
11 |     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT, \
12 |     `username` VARCHAR(20) NOT NULL, \
13 |     `coin` INT DEFAULT 0, \
14 |     `eth_address` VARCHAR(50),\
15 |     `bch_address` VARCHAR(50),\
16 |     `password` CHAR(60) NOT NULL, \
17 |         PRIMARY KEY (`id`), \
18 |     UNIQUE INDEX `id_UNIQUE` (`id` ASC), \
19 |     UNIQUE INDEX `username_UNIQUE` (`username` ASC) \
20 | )');
21 | 
22 | 
23 | connection.query('\
24 | CREATE TABLE `' + dbconfig.database + '`.`' + dbconfig.ethereum_transaction + '` ( \
25 |     `txhash` VARCHAR(100), \
26 |     `to_address` VARCHAR(50) NOT NULL, \
27 |     `to_user_id` VARCHAR(50) NOT NULL, \
28 |     `value` BIGINT DEFAULT 0, \
29 |     `blocknumber` INT,\
30 |     `timestamp` TIMESTAMP, \
31 |     PRIMARY KEY (`txhash`), \
32 |     INDEX `to_user_id` (`to_user_id` ASC) \
33 | )');
34 | 
35 | 
36 | connection.query("CREATE TABLE `" + dbconfig.database + '`.`' + dbconfig.eth_withdraw_log + "` ( \
37 |     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,\
38 |     `tx_status` INT DEFAULT 0 ,\
39 |     `tx_hash` VARCHAR(100), \
40 |     `from_address` VARCHAR(50) NOT NULL, \
41 |     `to_address` VARCHAR(50) NOT NULL, \
42 |     `to_user_id` VARCHAR(50) NOT NULL, \
43 |     `eth_value` BIGINT DEFAULT 0, \
44 |     `coin_value` INT DEFAULT 0, \
45 |     `block_number` INT,\
46 |     `timestamp` TIMESTAMP, \
47 |     PRIMARY KEY (`id`))");
48 | 
49 | 
50 | connection.query('\
51 | CREATE TABLE `' + dbconfig.database + '`.`' + dbconfig.bch_transaction + '` ( \
52 |     `txhash` VARCHAR(100), \
53 |     `to_address` VARCHAR(50) NOT NULL, \
54 |     `to_user_id` VARCHAR(50) NOT NULL, \
55 |     `value` BIGINT DEFAULT 0, \
56 |     `blocknumber` INT,\
57 |     `timestamp` TIMESTAMP, \
58 |     PRIMARY KEY (`txhash`), \
59 |     INDEX `to_user_id` (`to_user_id` ASC) \
60 | )');
61 | 
62 | 
63 | connection.query("CREATE TABLE `" + dbconfig.database + '`.`' + dbconfig.bch_withdraw_log + "` ( \
64 |     `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,\
65 |     `tx_status` INT DEFAULT 0 ,\
66 |     `tx_hash` VARCHAR(100), \
67 |     `from_address` VARCHAR(50) NOT NULL, \
68 |     `to_address` VARCHAR(50) NOT NULL, \
69 |     `to_user_id` VARCHAR(50) NOT NULL, \
70 |     `bch_value` BIGINT DEFAULT 0, \
71 |     `coin_value` INT DEFAULT 0, \
72 |     `block_number` INT,\
73 |     `timestamp` TIMESTAMP, \
74 |     PRIMARY KEY (`id`))");
75 | 
76 | console.log('Success: Database Created!');
77 | 
78 | connection.end();
79 | 


--------------------------------------------------------------------------------
/views/withdraw.ejs:
--------------------------------------------------------------------------------
  1 | <!-- views/withdraw.ejs -->
  2 | <!doctype html>
  3 | <html>
  4 | 
  5 | <head>
  6 | 	<title>Coins and Cryptocurrency Exchange</title>
  7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css">
  8 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css">
  9 | 	<script src='/assets/js/jquery-3.3.1.js'></script>
 10 | 
 11 | 	<style>
 12 | 		body 		{ padding-top:80px; word-wrap:break-word; }
 13 | 	</style>
 14 | </head>
 15 | <body>
 16 | <div class="container">
 17 | 
 18 | 	<div class="page-header text-center">
 19 | 		<h1><span class="fa fa-bitcoin"></span> Withdraw Coin</h1>
 20 | 		<a href="/logout" class="btn btn-default btn-sm">Logout</a>
 21 | 		<a href="/profile" class="btn btn-default btn-sm">Profile</a>
 22 | 
 23 | 	</div>
 24 | 
 25 | 	<div class="row">
 26 | 
 27 | 		<div class="col-sm-6">
 28 | 			<div class="well">
 29 | 				<p>
 30 | 					<strong>ID</strong>: <%= user.id %><br>
 31 | 					<strong>Username</strong>: <%= user.username %><br>
 32 | 					<strong>Coin</strong>: <%= user.coin %><br>
 33 | 					<strong>Ethereum</strong>: <%= user.eth_amount %><br>
 34 | 					<strong>Bitcoin Cash</strong>: <%= user.bch_amount %><br>
 35 | 
 36 | 				</p>
 37 | 				<p>
 38 | 				<form action="/ethwithdraw" method="post">
 39 | 					To Ethereum Address:
 40 | 					<input type="text" class="form-control" name="ethAddress" value="">
 41 | 					Withdraw coin amount:
 42 | 					<input type="text" class="form-control" name="ethAmount" value="">
 43 | 					<input type="submit" value="Submit">
 44 | 				</form>
 45 | 				<text id='ethTransaction'></text>
 46 | 
 47 | 				</p>
 48 | 				<p>
 49 | 				<form action="/bchwithdraw" method="post">
 50 | 					To Bitcoin Cash Address:
 51 | 					<input type="text" class="form-control" name="bchAddress" value="">
 52 | 					Withdraw coin amount:
 53 | 					<input type="text" class="form-control" name="bchAmount" value="">
 54 | 					<input type="submit" value="Submit">
 55 | 				</form>
 56 | 				<text id='bchTransaction'></text>
 57 | 				</p>
 58 | 
 59 | 			</div>
 60 | 		</div>
 61 | 
 62 | 	</div>
 63 | 
 64 | </div>
 65 | <script>
 66 | 	let eth_tx = get('eth_tx');
 67 |     let bch_tx = get('bch_tx');
 68 | 
 69 |     if(eth_tx!==undefined){
 70 |         getEthTx(eth_tx);
 71 | 	}
 72 | 
 73 |     if(bch_tx!==undefined){
 74 |         getBchTx(bch_tx);
 75 |     }
 76 |     function getBchTx(bch_tx) {
 77 |         $.ajax({
 78 |             type: 'GET',
 79 |             url:'/ajaxbchtx?bch_tx='+bch_tx,
 80 |             dataType:'json'
 81 |         })
 82 |             .done(function (data) {
 83 |                 if(data!==undefined)
 84 |                     $('#bchTransaction').html(JSON.stringify(data));
 85 |                 else
 86 |                     $('#bchTransaction').html('');
 87 |                 setTimeout(getBchTx,10000,bch_tx);
 88 |             })
 89 |             .fail(function (jqXHR,testStatus,err) {
 90 |                 console.log('AJAX error response:',testStatus)
 91 |             });
 92 |     }
 93 | 	function getEthTx(eth_tx) {
 94 |         $.ajax({
 95 |             type: 'GET',
 96 |             url:'/ajaxethtx?eth_tx='+eth_tx,
 97 |             dataType:'json'
 98 |         })
 99 |             .done(function (data) {
100 |                 if(data!==undefined)
101 |                     $('#ethTransaction').html(JSON.stringify(data));
102 |                 else
103 |                     $('#ethTransaction').html('');
104 |                 setTimeout(getEthTx,10000,eth_tx);
105 |             })
106 |             .fail(function (jqXHR,testStatus,err) {
107 |                 console.log('AJAX error response:',testStatus)
108 |             });
109 |     }
110 |     function get(name){
111 |         if(name=(new RegExp('[?&]'+encodeURIComponent(name)+'=([^&]*)')).exec(location.search))
112 |             return decodeURIComponent(name[1]);
113 |     }
114 | </script>
115 | </body>
116 | 
117 | </html>
118 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | #################
  2 | ## Eclipse
  3 | #################
  4 | 
  5 | *.pydevproject
  6 | .project
  7 | .metadata
  8 | bin/
  9 | tmp/
 10 | *.tmp
 11 | *.bak
 12 | *.swp
 13 | *~.nib
 14 | local.properties
 15 | .classpath
 16 | .settings/
 17 | .loadpath
 18 | 
 19 | # External tool builders
 20 | .externalToolBuilders/
 21 | 
 22 | # Locally stored "Eclipse launch configurations"
 23 | *.launch
 24 | 
 25 | # CDT-specific
 26 | .cproject
 27 | 
 28 | # PDT-specific
 29 | .buildpath
 30 | 
 31 | 
 32 | #################
 33 | ## Visual Studio
 34 | #################
 35 | 
 36 | ## Ignore Visual Studio temporary files, build results, and
 37 | ## files generated by popular Visual Studio add-ons.
 38 | 
 39 | # User-specific files
 40 | *.suo
 41 | *.user
 42 | *.sln.docstates
 43 | 
 44 | # Build results
 45 | 
 46 | [Dd]ebug/
 47 | [Rr]elease/
 48 | x64/
 49 | build/
 50 | [Bb]in/
 51 | [Oo]bj/
 52 | 
 53 | # MSTest test Results
 54 | [Tt]est[Rr]esult*/
 55 | [Bb]uild[Ll]og.*
 56 | 
 57 | *_i.c
 58 | *_p.c
 59 | *.ilk
 60 | *.meta
 61 | *.obj
 62 | *.pch
 63 | *.pdb
 64 | *.pgc
 65 | *.pgd
 66 | *.rsp
 67 | *.sbr
 68 | *.tlb
 69 | *.tli
 70 | *.tlh
 71 | *.tmp
 72 | *.tmp_proj
 73 | *.log
 74 | *.vspscc
 75 | *.vssscc
 76 | .builds
 77 | *.pidb
 78 | *.log
 79 | *.scc
 80 | 
 81 | # Visual C++ cache files
 82 | ipch/
 83 | *.aps
 84 | *.ncb
 85 | *.opensdf
 86 | *.sdf
 87 | *.cachefile
 88 | 
 89 | # Visual Studio profiler
 90 | *.psess
 91 | *.vsp
 92 | *.vspx
 93 | 
 94 | # Guidance Automation Toolkit
 95 | *.gpState
 96 | 
 97 | # ReSharper is a .NET coding add-in
 98 | _ReSharper*/
 99 | *.[Rr]e[Ss]harper
100 | 
101 | # TeamCity is a build add-in
102 | _TeamCity*
103 | 
104 | # DotCover is a Code Coverage Tool
105 | *.dotCover
106 | 
107 | # NCrunch
108 | *.ncrunch*
109 | .*crunch*.local.xml
110 | 
111 | # Installshield output folder
112 | [Ee]xpress/
113 | 
114 | # DocProject is a documentation generator add-in
115 | DocProject/buildhelp/
116 | DocProject/Help/*.HxT
117 | DocProject/Help/*.HxC
118 | DocProject/Help/*.hhc
119 | DocProject/Help/*.hhk
120 | DocProject/Help/*.hhp
121 | DocProject/Help/Html2
122 | DocProject/Help/html
123 | 
124 | # Click-Once directory
125 | publish/
126 | 
127 | # Publish Web Output
128 | *.Publish.xml
129 | *.pubxml
130 | 
131 | # NuGet Packages Directory
132 | ## TODO: If you have NuGet Package Restore enabled, uncomment the next line
133 | #packages/
134 | 
135 | # Windows Azure Build Output
136 | csx
137 | *.build.csdef
138 | 
139 | # Windows Store app package directory
140 | AppPackages/
141 | 
142 | # Others
143 | sql/
144 | *.Cache
145 | ClientBin/
146 | [Ss]tyle[Cc]op.*
147 | ~$*
148 | *~
149 | *.dbmdl
150 | *.[Pp]ublish.xml
151 | *.pfx
152 | *.publishsettings
153 | 
154 | # RIA/Silverlight projects
155 | Generated_Code/
156 | 
157 | # Backup & report files from converting an old project file to a newer
158 | # Visual Studio version. Backup files are not needed, because we have git ;-)
159 | _UpgradeReport_Files/
160 | Backup*/
161 | UpgradeLog*.XML
162 | UpgradeLog*.htm
163 | 
164 | # SQL Server files
165 | App_Data/*.mdf
166 | App_Data/*.ldf
167 | 
168 | #############
169 | ## Windows detritus
170 | #############
171 | 
172 | # Windows image file caches
173 | Thumbs.db
174 | ehthumbs.db
175 | 
176 | # Folder config file
177 | Desktop.ini
178 | 
179 | # Recycle Bin used on file shares
180 | $RECYCLE.BIN/
181 | 
182 | # Mac crap
183 | .DS_Store
184 | 
185 | 
186 | #############
187 | ## Python
188 | #############
189 | 
190 | *.py[co]
191 | 
192 | # Packages
193 | *.egg
194 | *.egg-info
195 | dist/
196 | build/
197 | eggs/
198 | parts/
199 | var/
200 | sdist/
201 | develop-eggs/
202 | .installed.cfg
203 | 
204 | # Installer logs
205 | pip-log.txt
206 | 
207 | # Unit test / coverage reports
208 | .coverage
209 | .tox
210 | 
211 | #Translations
212 | *.mo
213 | 
214 | #Mr Developer
215 | .mr.developer.cfg
216 | 
217 | ######
218 | # Idea
219 | ######
220 | .idea/
221 | 
222 | ##############
223 | # node modules
224 | ##############
225 | node_modules/
226 | 


--------------------------------------------------------------------------------
/service/keystorebch.js:
--------------------------------------------------------------------------------
  1 | var BCHConfig = require('./../config/bchconfig')//Bitcoin Cash Configurations
  2 | 
  3 | const fs = require('fs');//File system
  4 | 
  5 | var DBService = require('./../service/db_service');//Mysql Database Services
  6 | 
  7 | // RPC connection to the bitcoin cash node
  8 | var BCHRpc = require("./../service/bitcoincashrpc");
  9 | var BCHRpcConnect = new BCHRpc(BCHConfig.host, BCHConfig.username, BCHConfig.password, BCHConfig.port, 3000);
 10 | 
 11 | //Nodejs bitcoin cash modules
 12 | var BCHCashCore = require("bitcoincashjs");
 13 | var HDPublicKey = BCHCashCore.HDPublicKey;
 14 | var HDPrivateKey = BCHCashCore.HDPrivateKey;
 15 | var Address = BCHCashCore.Address;
 16 | 
 17 | 
 18 | var hdPublicKey;
 19 | var hdPrivateKey;
 20 | 
 21 | // withdrawSource array includes each withdraw source account's private key and address. The address is Base58check format.
 22 | var withdrawSource=[];
 23 | 
 24 | function initBCHPublicKey(callback) {
 25 |         fs.readFile('keystorebchpublic.txt', 'utf8', function(err, data) {
 26 |                 if (err) {
 27 |                     console.log(err);
 28 | 
 29 |                 }
 30 |                 else{
 31 |                     hdPublicKey = new HDPublicKey(data);
 32 |                     return callback;
 33 |                 }
 34 |             }
 35 | 
 36 |         );
 37 | 
 38 | };
 39 | 
 40 | function initBCHPrivateKey(callback) {
 41 |     fs.readFile('keystorebchprivate.txt', 'utf8', function(err, data) {
 42 |             if (err) {
 43 |                 return callback(err);
 44 | 
 45 |             }
 46 |             else{
 47 |                 hdPrivateKey = new HDPrivateKey(data);
 48 |                 return callback(null,hdPrivateKey);
 49 |             }
 50 |         }
 51 | 
 52 |     );
 53 | 
 54 | };
 55 | 
 56 | 
 57 | //Add addresses in withdrawSource array into bitcoin cash node with account "withdraw source". Make it possisble to check unspent transactions from nodejs.
 58 | function addWithdrawSourceAddrToWallet(callback) {
 59 | 
 60 |     if(withdrawSource.length===0)
 61 |         setWithdrawSource();
 62 |     var BCC = require("./../service/bitcoincashrpc");
 63 |     var BCHRrcClient = new BCC(BCHConfig.host, BCHConfig.username, BCHConfig.password, BCHConfig.port, 3000);//Bitcoin Cash RPC Connection
 64 |     var p;
 65 |     for(var i=0;i<withdrawSource.length;i++){
 66 |         p =  Promise.resolve(BCHRpcConnect.importaddress(withdrawSource[i].address.toString(),"withdrawSource",false));
 67 |     }
 68 |     p.then(info=>{
 69 |         return callback(null, i);
 70 |     });
 71 | };
 72 | 
 73 | 
 74 | //set up withdrawSource Array
 75 | function setWithdrawSource() {
 76 |     var hdPath = BCHConfig.withdrawSourceHDPath;
 77 |     for (var i=0; i< hdPath.length; i++){
 78 |         var derivedPrivateKey = hdPrivateKey.derive(hdPath[i]);
 79 |         var derivedAddressBase58Check = new Address(derivedPrivateKey.publicKey, BCHConfig.network,'pubkeyhash');
 80 |         withdrawSource.push({derivedPrivateKey:derivedPrivateKey,address: derivedAddressBase58Check.toString()});
 81 |     }
 82 | };
 83 | 
 84 | function updateUserToAddress(username) {
 85 | 
 86 |     var derivedByArgument = hdPublicKey.derive("m/0/0");
 87 |     DBService.getUserByUsername(username,function (err, users) {
 88 |         if(err)
 89 |         {
 90 |             console.log(err);
 91 |             return;
 92 |         }else{
 93 |             var userid = users[0].id;
 94 |             var derivedAddressBase58Check = new Address(derivedByArgument.derive(userid).publicKey, BCHConfig.network,'pubkeyhash');
 95 |             var BASE58CHECK = BCHCashCore.encoding.Base58Check;
 96 |             var derivedAddressHex ="0x"+BASE58CHECK.decode(derivedAddressBase58Check.toString()).toString('hex').slice(2);
 97 | 
 98 |             var updateList ={bch_address:derivedAddressHex};
 99 |             DBService.updateUsersById(userid,updateList,function (err2,data2) {
100 |                 if(err2){
101 |                     console.log(err);
102 |                     return;
103 |                 }
104 |                 else{
105 |                     console.log("The new username "+ username+", BCH Hex address is "+ derivedAddressHex+". BCH Base58check address is "+derivedAddressBase58Check.toString());
106 |                     var p =  Promise.resolve(BCHRpcConnect.importaddress(derivedAddressBase58Check.toString(),username,false));
107 |                     p.then(info=>{
108 |                         console.log("Import the address to the node wallet!")
109 |                     });
110 |                 }
111 |             });
112 |         }
113 |     });
114 | };
115 | 
116 | module.exports ={
117 |    init:function(callback){
118 |        initBCHPublicKey();
119 |        initBCHPrivateKey(function (err, privateKey) {
120 |            if(err)
121 |                return (err);
122 |            else {
123 |                setWithdrawSource();
124 |                addWithdrawSourceAddrToWallet(function (err, amount) {
125 |                    if (err)
126 |                        return callback(err);
127 |                    else{
128 |                        return callback(null);
129 |                    }
130 |                });
131 |            }
132 | 
133 |        });
134 |    },
135 |     updateUserToAddress:updateUserToAddress, 
136 |     withdrawSource:withdrawSource,
137 |     hdPrivateKey:hdPrivateKey,
138 |     setWithdrawSource:setWithdrawSource,
139 | }
140 | 


--------------------------------------------------------------------------------
/service/keystoreeth.js:
--------------------------------------------------------------------------------
  1 | var dbconfig = require('./../config/database');
  2 | var ethconfig = require('./../config/ethereum');
  3 | const DBSERVICE = require('./../service/db_service');
  4 | const fs = require('fs');
  5 | 
  6 | var ks ;
  7 | 
  8 | function setksintance(ksi) {
  9 |     ks = ksi;
 10 |     console.log('The key store instance is good...'+ks);
 11 | };
 12 | 
 13 | function getKeyStore() {
 14 |     return ks;
 15 | };
 16 | 
 17 | function initKeystore(callback) {
 18 |         const fs = require('fs');
 19 |         ks = fs.readFile('keystore.txt', 'utf8', function(err, data) {
 20 |                 if (err) {
 21 |                     console.log(err);
 22 |                     var lightwallet = require('eth-lightwallet');
 23 |                     var seed = lightwallet.keystore.generateRandomSeed();
 24 |                     var password = Math.random().toString();
 25 |                     console.log('The seed is '+seed);
 26 |                     console.log('The password is '+password);
 27 | 
 28 |                     lightwallet.keystore.createVault({
 29 |                         password: password,
 30 |                         seedPhrase: seed,
 31 |                         hdPathString: "m/0'/0'/0'"
 32 |                     }, function (err, ks) {
 33 | 
 34 |                         if(err){
 35 |                             console.log(err);
 36 |                             return callback(false);
 37 |                         }else{
 38 | 
 39 |                             ks.keyFromPassword(password, function (err, pwDerivedKey) {
 40 |                                 if(err)
 41 |                                 {
 42 |                                     console.log('Error keystore instance from password!');
 43 |                                     return callback(false);
 44 |                                 }
 45 |                                 else
 46 |                                 {
 47 |                                     var serialized = ks.serialize();
 48 | 
 49 |                                     fs.writeFile('keystore.txt', serialized, function(err){
 50 |                                         // throws an error, you could also catch it here
 51 |                                         if (err) throw err;
 52 | 
 53 |                                         // success case, the file was saved
 54 |                                         console.log('Keystore saved!');
 55 |                                         return callback(true,ks);
 56 | 
 57 | 
 58 |                                     });
 59 | 
 60 |                                 }
 61 | 
 62 |                             });
 63 | 
 64 |                         }
 65 | 
 66 |                     });
 67 |                 }
 68 |                 else{
 69 |                     var deserialize = data;
 70 |                     var lightwallet = require('eth-lightwallet');
 71 |                     var keystoreinstance = lightwallet.keystore.deserialize(deserialize);
 72 |                     console.log("Load keystore from local file.");
 73 | 
 74 |                     keystoreinstance.keyFromPassword(ethconfig.keyStorePassword, function (err, pwDerivedKey) {
 75 |                         if(err)
 76 |                         {
 77 |                             console.log(err);
 78 |                         }else{
 79 |                             keystoreinstance.passwordProvider = function (callback) {
 80 |                                 callback(null, ethconfig.keyStorePassword);
 81 |                             };
 82 |                         }
 83 |                     });
 84 |                     return callback(true,keystoreinstance);
 85 | 
 86 |                 }
 87 |             }
 88 | 
 89 |         );
 90 | 
 91 | };
 92 | 
 93 | function updateUserToAddress(username) {
 94 | 
 95 |     ks.keyFromPassword(ethconfig.keyStorePassword, function (err, pwDerivedKey) {
 96 |         if(err)
 97 |         {
 98 |             return console(err);
 99 |         }
100 |         else
101 |         {
102 |             DBSERVICE.getUserByUsername(username,function (err,data) {
103 |                 if(err) {
104 |                     console.log(err);
105 |                     return;
106 |                 }
107 |                 if(ks.getAddresses().length <data[0].id)
108 |                 {
109 |                     ks.generateNewAddress(pwDerivedKey,data[0].id-ks.getAddresses().length)
110 |                 }
111 |                 let address = ks.getAddresses()[data[0].id-1];
112 |                 let updateList ={eth_address:address};
113 |                 DBSERVICE.updateUsersByUsername(username,updateList,function (err,data) {
114 |                     if(err){
115 |                         console.log(err);
116 |                         return;
117 |                     }
118 |                     else{
119 |                         console.log("The new username "+ username+", ETH address is "+ address);
120 |                         const ETH_TX = require('./../app/eth_transactions');
121 |                         ETH_TX.addRecipientAddresses(address);
122 |                         var serialized = ks.serialize();
123 |                         fs.writeFile('keystore.txt', serialized, function(err){
124 |                             if (err) throw err;
125 |                             // success case, the file was saved
126 |                             console.log('Keystore new key saved to file!');
127 |                         });
128 |                     }
129 |                 })
130 | 
131 |             });
132 |         }
133 |     });
134 | 
135 | };
136 | 
137 | module.exports ={
138 |     getKeyStore: getKeyStore,
139 |    init: function (callback) {
140 |        initKeystore(function (isSucceed, ksi) {
141 |            if(isSucceed){
142 |                setksintance(ksi);
143 |                return callback(true,ksi);
144 |            }
145 |        });
146 |    },
147 |     updateUserToAddress:updateUserToAddress
148 | }
149 | 


--------------------------------------------------------------------------------
/config/passport.js:
--------------------------------------------------------------------------------
  1 | // config/passport.js
  2 | 
  3 | // load all the things we need
  4 | var LocalStrategy   = require('passport-local').Strategy;
  5 | 
  6 | var keystore = require('./../service/keystoreeth');
  7 | var bchKeyUtils = require("./../service/keystorebch");
  8 | 
  9 | // load up the user model
 10 | var mysql = require('mysql');
 11 | var bcrypt = require('bcrypt-nodejs');
 12 | var dbconfig = require('./database');
 13 | var connection = mysql.createConnection(dbconfig.connection);
 14 | const fs = require('fs');
 15 | 
 16 | 
 17 | connection.query('USE ' + dbconfig.database);
 18 | // expose this function to our app using module.exports
 19 | module.exports = function(passport) {
 20 | 
 21 |     // =========================================================================
 22 |     // passport session setup ==================================================
 23 |     // =========================================================================
 24 |     // required for persistent login sessions
 25 |     // passport needs ability to serialize and unserialize users out of session
 26 | 
 27 |     // used to serialize the user for the session
 28 |     passport.serializeUser(function(user, done) {
 29 |         done(null, user.id);
 30 |     });
 31 | 
 32 |     // used to deserialize the user
 33 |     passport.deserializeUser(function(id, done) {
 34 |         connection.query("SELECT * FROM users WHERE id = ? ",[id], function(err, rows){
 35 |             done(err, rows[0]);
 36 |         });
 37 |     });
 38 | 
 39 |     // =========================================================================
 40 |     // LOCAL SIGNUP ============================================================
 41 |     // =========================================================================
 42 |     // we are using named strategies since we have one for login and one for signup
 43 |     // by default, if there was no name, it would just be called 'local'
 44 | 
 45 |     passport.use(
 46 |         'local-signup',
 47 |         new LocalStrategy({
 48 |             // by default, local strategy uses username and password, we will override with email
 49 |             usernameField : 'username',
 50 |             passwordField : 'password',
 51 |             passReqToCallback : true // allows us to pass back the entire request to the callback
 52 |         },
 53 |         function(req, username, password, done) {
 54 |             // find a user whose email is the same as the forms email
 55 |             // we are checking to see if the user trying to login already exists
 56 |             connection.query("SELECT * FROM users WHERE username = ?",[username], function(err, rows) {
 57 |                 if (err)
 58 |                     return done(err);
 59 |                 if (rows.length) {
 60 |                     return done(null, false, req.flash('signupMessage', 'That username is already taken.'));
 61 |                 } else {
 62 |                     // if there is no user with that username
 63 |                     // create the user
 64 | 
 65 |                     var newUserMysql = {
 66 |                         username: username,
 67 |                         password: bcrypt.hashSync(password, null, null) , // use the generateHash function in our user model
 68 |                         coin: 0
 69 |                     };
 70 | 
 71 |                     var insertQuery = "INSERT INTO users ( username, password ) values (?,?)";
 72 | 
 73 |                     connection.query(insertQuery,[newUserMysql.username, newUserMysql.password],function(err, rows) {
 74 |                         if(err){
 75 |                             console.log(err);
 76 |                             return;
 77 |                         }
 78 |                         newUserMysql.id = rows.insertId;
 79 |                         console.log('The new user is created successful!');
 80 |                         keystore.updateUserToAddress(username);
 81 |                         bchKeyUtils.updateUserToAddress(username);
 82 |                         return done(null, newUserMysql);
 83 |                     });
 84 | 
 85 | 
 86 |                 }
 87 |             });
 88 |         })
 89 |     );
 90 | 
 91 |     // =========================================================================
 92 |     // LOCAL LOGIN =============================================================
 93 |     // =========================================================================
 94 |     // we are using named strategies since we have one for login and one for signup
 95 |     // by default, if there was no name, it would just be called 'local'
 96 | 
 97 |     passport.use(
 98 |         'local-login',
 99 |         new LocalStrategy({
100 |             // by default, local strategy uses username and password, we will override with email
101 |             usernameField : 'username',
102 |             passwordField : 'password',
103 |             passReqToCallback : true // allows us to pass back the entire request to the callback
104 |         },
105 |         function(req, username, password, done) { // callback with email and password from our form
106 | 
107 | 
108 | 
109 |             connection.query("SELECT * FROM users WHERE username = ?",[username], function(err, rows){
110 |                 if (err)
111 |                     return done(err);
112 |                 if (!rows.length) {
113 |                     return done(null, false, req.flash('loginMessage', 'No user found.')); // req.flash is the way to set flashdata using connect-flash
114 |                 }
115 | 
116 |                 // if the user is found but the password is wrong
117 |                 if (!bcrypt.compareSync(password, rows[0].password))
118 |                     return done(null, false, req.flash('loginMessage', 'Oops! Wrong password.')); // create the loginMessage and save it to session as flashdata
119 | 
120 |                 // all is well, return successful user
121 |                 return done(null, rows[0]);
122 |             });
123 |         })
124 |     );
125 | };
126 | 


--------------------------------------------------------------------------------
/views/deposit.ejs:
--------------------------------------------------------------------------------
  1 | <!-- views/profile.ejs -->
  2 | <!doctype html>
  3 | <html>
  4 | 
  5 | <head>
  6 | 	<title>Coins and Cryptocurrency Exchange</title>
  7 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.2/css/bootstrap.min.css">
  8 | 	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css">
  9 | 	<script src='/assets/js/jquery-3.3.1.js'></script>
 10 | 	<style>
 11 | 		body 		{ padding-top:80px; word-wrap:break-word; }
 12 | 	</style>
 13 | </head>
 14 | <body class="text-center">
 15 | <div class="container">
 16 | 
 17 | 	<div class="page-header text-center">
 18 | 		<h1><span class="fa fa-bitcoin"></span> Deposit Coin</h1>
 19 |         <h4 class='text-left'><strong>User Name:</strong><%= user.username %></h4>
 20 |         <h4 class='text-left'><strong>Coin Amount:</strong><text id="coinBalance"><%= user.coin %></text> </h4>
 21 | 
 22 |         <a href="/logout" class="btn btn-default btn-sm">Logout</a>
 23 | 		<a href="/profile" class="btn btn-default btn-sm">Profile</a>
 24 | 
 25 | 	</div>
 26 | 
 27 | 	<div class="row">
 28 | 		<!--<div class="page-header text-center">-->
 29 | 			<!---->
 30 | 		<!--</div>-->
 31 | 		<!-- LOCAL INFORMATION -->
 32 | 		<div class="col-sm-6">
 33 | 			<div class="well">
 34 | 				<h5><span class="fa fa-btc"></span> Ethereum</h5>
 35 |                 <p class="text-left"><strong>Address: </strong><%= user.eth_address %></p>
 36 |                 <p class="text-left"><strong>Balance (GWeis): </strong><text id="ethBalance"><%= user.eth_amount %></text></p>
 37 |                 <p>
 38 |                         <!--<strong>imageURL</strong>: <%= imgUrlEth %><br>-->
 39 | 						<canvas id="ETHQRCODE"></canvas><br>
 40 | 						<!--<div id="urld" style="display:none"><%= imgUrlEth %></div><br>-->
 41 | 				</p>
 42 |                     <button id ="getButton" onclick="getEthPending()" class="btn btn-lg btn-primary btn-block">Check Deposits</button><br>
 43 | 			</div>
 44 |             <text class="text-left" id="getResponse"></text>
 45 |         </div>
 46 | 		<div class="col-sm-6">
 47 | 			<div class="well">
 48 | 				<h5 ><span class="fa fa-btc"></span> Bitcoin Cash</h5>
 49 |                 <p class="text-left"><strong>Address: </strong><%= user.bch_address %></p>
 50 |                 <p class="text-left"><strong>Balance (Satoshi): </strong><text id="bchBalance"><%= user.bch_amount %></text></p>
 51 | 				<p>
 52 | 					<!--<strong>imageURL</strong>: <%= imgUrlBCH %><br>-->
 53 | 					<canvas id="BCHQRCODE"></canvas><br>
 54 | 					<!--<div id="urld" style="display:none"><%= imgUrlBCH %></div><br>-->
 55 | 				</p>
 56 |                 <button id ="getBCHButton" onclick="getBCHPending()" class="btn btn-lg btn-primary btn-block">Check Deposits</button><br>
 57 |             </div>
 58 |             <text class="text-left" id="getBCHResponse"></text>
 59 |         </div>
 60 | 	</div>
 61 | 
 62 | 
 63 | 	<script>
 64 | 		var myCanvasEth = document.getElementById('ETHQRCODE');
 65 | 		var ctxEth = myCanvasEth.getContext('2d');
 66 | 		var imgEth = new Image;
 67 | 		imgEth.onload = function(){
 68 | 			ctxEth.drawImage(imgEth,0,0); // Or at whatever offset you like
 69 | 		};
 70 | 		imgEth.src = "<%= imgUrlEth %>";
 71 | 
 72 |         var myCanvasBch = document.getElementById('BCHQRCODE');
 73 |         var ctxBch = myCanvasBch.getContext('2d');
 74 |         var imgBch = new Image;
 75 |         imgBch.onload = function(){
 76 |             ctxBch.drawImage(imgBch,0,0); // Or at whatever offset you like
 77 |         };
 78 |         imgBch.src = "<%= imgUrlEth %>";
 79 | 
 80 | /*
 81 |         $("#getButton").on("click",function () {
 82 |             $.ajax({
 83 |                 type: 'GET',
 84 |                 url:'/ajaxdeposit',
 85 |                 dataType:'json'
 86 |             })
 87 |                 .done(function (data) {
 88 |                     console.log('GET response:',JSON.stringify(data));
 89 |                     if(data.length>0) $('#getResponse').html(JSON.stringify(data));
 90 | 
 91 |                 })
 92 |                 .fail(function (jqXHR,testStatus,err) {
 93 |                     console.log('AJAX error response:',testStatus)
 94 |                 });
 95 |         });*/
 96 | 
 97 |         var pendingAmount=0;
 98 |         var pendingBCHAmount=0;
 99 |         function getEthBalance() {
100 |             $.ajax({
101 |                 type: 'GET',
102 |                 url:'/ajaxethbalance',
103 |                 dataType:'json'
104 |             })
105 |                 .done(function (data) {
106 |                         $('#ethBalance').html(data.ethBalance);
107 |                     })
108 |                 .fail(function (jqXHR,testStatus,err) {
109 |                     console.log('AJAX error response:',testStatus)
110 |                 });
111 |         }
112 | 
113 |         function getBCHBalance() {
114 |             $.ajax({
115 |                 type: 'GET',
116 |                 url:'/ajaxbchbalance',
117 |                 dataType:'json'
118 |             })
119 |                 .done(function (data) {
120 |                     console.log('The BCH Balance is '+data.bchBalance);
121 |                     $('#bchBalance').html(data.bchBalance);
122 |                 })
123 |                 .fail(function (jqXHR,testStatus,err) {
124 |                     console.log('AJAX error response:',testStatus)
125 |                 });
126 |         }
127 | 
128 |         function getCoinBalance() {
129 |             $.ajax({
130 |                 type: 'GET',
131 |                 url:'/ajaxcoinbalance',
132 |                 dataType:'json'
133 |             })
134 |                 .done(function (data) {
135 |                     console.log('Coin balance is '+data.coinBalance);
136 |                     $('#coinBalance').html(data.coinBalance);
137 |                 })
138 |                 .fail(function (jqXHR,testStatus,err) {
139 |                     console.log('AJAX error response:',testStatus)
140 |                 });
141 |         }
142 |         function getEthPending () {
143 |             $.ajax({
144 |                 type: 'GET',
145 |                 url:'/ajaxdeposit',
146 |                 dataType:'json'
147 |             })
148 |                 .done(function (data) {
149 |                     if(data.length<pendingAmount){
150 |                         getEthBalance();
151 |                         getCoinBalance()
152 |                     }
153 |                     pendingAmount=data.length;
154 |                     if(data.length>0)
155 |                         $('#getResponse').html(JSON.stringify(data));
156 |                     else
157 |                         $('#getResponse').html('');
158 | 
159 |                     setTimeout(getEthPending,10000);
160 | 
161 |                 })
162 |                 .fail(function (jqXHR,testStatus,err) {
163 |                     console.log('AJAX error response:',testStatus)
164 |                 });
165 |         };
166 |         function getBCHPending () {
167 |             $.ajax({
168 |                 type: 'GET',
169 |                 url:'/ajaxbchdeposit',
170 |                 dataType:'json'
171 |             })
172 |                 .done(function (data) {
173 |                     console.log(data);
174 |                     if(data.length<pendingBCHAmount){
175 |                         getBCHBalance();
176 |                         getCoinBalance()
177 |                     }
178 |                     pendingBCHAmount=data.length;
179 |                     if(data.length>0)
180 |                         $('#getBCHResponse').html(JSON.stringify(data));
181 |                     else
182 |                         $('#getBCHResponse').html('');
183 | 
184 |                     setTimeout(getBCHPending,10000);
185 | 
186 |                 })
187 |                 .fail(function (jqXHR,testStatus,err) {
188 |                     console.log('AJAX error response:',testStatus)
189 |                 });
190 |         };
191 | 	</script>
192 | </div>
193 | 
194 | </body>
195 | 
196 | </html>
197 | 


--------------------------------------------------------------------------------
/app/routes.js:
--------------------------------------------------------------------------------
  1 | // app/routes.js
  2 | module.exports = function(app, passport) {
  3 | 	app.use(function(req, res, next){
  4 | 
  5 | 		next();
  6 | 	});
  7 | 
  8 | 	// =====================================
  9 | 	// HOME PAGE (with login links) ========
 10 | 	// =====================================
 11 | 	app.get('/', function(req, res) {
 12 | 		res.render('index.ejs'); // load the index.ejs file
 13 | 	});
 14 | 
 15 | 	// =====================================
 16 | 	// LOGIN ===============================
 17 | 	// =====================================
 18 | 	// show the login form
 19 | 	app.get('/login', function(req, res) {
 20 | 
 21 | 		// render the page and pass in any flash data if it exists
 22 | 		res.render('login.ejs', { message: req.flash('loginMessage') });
 23 | 	});
 24 | 
 25 | 	// process the login form
 26 | 	app.post('/login', passport.authenticate('local-login', {
 27 |             successRedirect : '/profile', // redirect to the secure profile section
 28 |             failureRedirect : '/login', // redirect back to the signup page if there is an error
 29 |             failureFlash : true // allow flash messages
 30 | 		}),
 31 |         function(req, res) {
 32 |             console.log("hello");
 33 | 
 34 |             if (req.body.remember) {
 35 |               req.session.cookie.maxAge = 1000 * 60 * 3;
 36 |             } else {
 37 |               req.session.cookie.expires = false;
 38 |             }
 39 |         res.redirect('/');
 40 |     });
 41 | 
 42 | 	// =====================================
 43 | 	// SIGNUP ==============================
 44 | 	// =====================================
 45 | 	// show the signup form
 46 | 	app.get('/signup', function(req, res) {
 47 | 		// render the page and pass in any flash data if it exists
 48 | 		res.render('signup.ejs', { message: req.flash('signupMessage') });
 49 | 	});
 50 | 
 51 | 	// process the signup form
 52 | 	app.post('/signup', passport.authenticate('local-signup', {
 53 | 		successRedirect : '/profile', // redirect to the secure profile section
 54 | 		failureRedirect : '/signup', // redirect back to the signup page if there is an error
 55 | 		failureFlash : true // allow flash messages
 56 | 	}));
 57 | 
 58 | 	// =====================================
 59 | 	// PROFILE SECTION =========================
 60 | 	// =====================================
 61 | 	// we will want this protected so you have to be logged in to visit
 62 | 	// we will use route middleware to verify this (the isLoggedIn function)
 63 | 	app.get('/profile', isLoggedIn, function(req, res) {
 64 | 		console.log(req.session.id)
 65 |         let user = req.user;
 66 |         let DBService = require('./../service/db_service');
 67 | 		let ETHTransaction = require('./eth_transactions');
 68 |         let BCHTransaction = require('./bch_transactions');
 69 | 
 70 |         DBService.getUserByUsername(user.username,function (err,data) {
 71 |             if(err) {
 72 |                 console.log(err);
 73 |                 user.eth_value = -1;
 74 |             }
 75 |             else
 76 |                 ETHTransaction.getETHBalanceByUserId(data[0].id,function (err,ethData) {
 77 |                     if(!err){
 78 |                         user.eth_value = ethData;
 79 |                         BCHTransaction.getBCHBalanceByUserId(this.userId,function (err,bchData) {
 80 |                             if(!err){
 81 |                                 user.bch_value = bchData;
 82 |                             }
 83 |                             res.render('profile.ejs', {user : user});
 84 |                         })
 85 |                     }
 86 |                     else
 87 |                     res.render('profile.ejs', {
 88 |                         user : user // get the user out of session and pass to template
 89 |                     });
 90 |                 }.bind({userId:data[0].id}))
 91 |         })
 92 | 	});
 93 | 
 94 | 	// =====================================
 95 | 	// LOGOUT ==============================
 96 | 	// =====================================
 97 | 	app.get('/logout', function(req, res) {
 98 | 		req.logout();
 99 | 		res.redirect('/');
100 | 	});
101 | 
102 | 
103 | 	//Leo 绘制eth转账二维码界面
104 | 	app.get('/deposit', isLoggedIn,function(req, res) {
105 | 		// render the page and pass in any flash data if it exist
106 | 		var QRCode = require('qrcode');
107 | 		const DBService =require('./../service/db_service');
108 |         let ETHTransaction = require('./eth_transactions');
109 |         let BCHTransaction = require('./bch_transactions');
110 | 		DBService.getUserByUsername(req.user.username,function (err, rows) {
111 |             if (err){
112 |                 console.log(err);
113 |                 //	return done(false);
114 |             }
115 |             if (rows.length==0){
116 |                 console.log("Cannot find this user name in DB!");
117 |                 //	return done(false);
118 |             }
119 |             QRCode.toDataURL(rows[0].eth_address, function (err, url) {
120 |             	let eth_url = url;
121 |             	QRCode.toDataURL(this.row.bch_address,function (err1,url1) {
122 |                     let bch_url = url1;
123 |                     let user = this.req.user;
124 |                     user.eth_address = this.row.eth_address;
125 |                     user.bch_address = this.row.bch_address;
126 |                     ETHTransaction.getETHBalanceByUserId(this.row.id,function (err,ethData) {
127 |                         user.eth_amount=ethData;
128 |                         BCHTransaction.getBCHBalanceByUserId(this.row.id,function (err,bchData) {
129 |                             user.bch_amount=bchData;
130 |                             this.res.render('deposit.ejs', { user: user, imgUrlEth: eth_url,imgUrlBCH:bch_url});
131 |                         }.bind({row:this.row,res:res,req:req,user:user}))
132 |                     }.bind({row:this.row,res:res,req:req,user:user}));
133 |                 }.bind({row: rows[0],res:res,req:req}))
134 |             }.bind({row: rows[0],res:res,req:req}))
135 |         });
136 | 	});
137 | 
138 | 	//Leo  eth转出接口
139 | 	app.post('/ethwithdraw',isLoggedIn,function(req, res){
140 | 		let Eth = require('./eth_transactions');
141 |         Eth.withdrawETH(req.user.username,req.body.ethAddress,req.body.ethAmount,function (err,data) {
142 | 			if(err) console.log(err);
143 | 			else{
144 |  //               res.render('withdraw.ejs', { user: req.user,msg: "Coin was withdrawn as Ethereum. The transaction ID is "+data});
145 |                   res.redirect('/withdraw?eth_tx='+data,);
146 | 
147 |             }
148 |         });
149 | 
150 | 	});
151 |     app.post('/bchwithdraw',isLoggedIn,function(req, res){
152 |     	console.log(req.user);
153 |         let Bch = require('./bch_transactions');
154 |         Bch.withdrawBCH(req.user.username,req.body.bchAddress,req.body.bchAmount,function (err,data) {
155 |             if(err) console.log(err);
156 |             else{
157 | //                res.render('withdraw.ejs', { user: req.user,msg: "Coin was withdrawn as Bitcoin Cash. The transaction ID is "+data});
158 |                 res.redirect('/withdraw?bch_tx='+data,);
159 |             }
160 |         });
161 | 
162 |     });
163 |     app.get('/withdraw',isLoggedIn,function(req, res){
164 |         const DBService =require('./../service/db_service');
165 |         let ETHTransaction = require('./eth_transactions');
166 |         let BCHTransaction = require('./bch_transactions');
167 |         console.log(req.body);
168 |         ETHTransaction.getETHBalanceByUserId(req.user.id,function (err,ethData) {
169 |             this.req.user.eth_amount=ethData;
170 |             BCHTransaction.getBCHBalanceByUserId(this.req.user.id,function (err,bchData) {
171 |                 this.req.user.bch_amount=bchData;
172 |                 res.render('withdraw.ejs', { user: req.user});
173 |             }.bind({res:res,req:req}))
174 |         }.bind({res:res,req:req}));
175 | 
176 |     });
177 | 
178 |     app.get('/ajaxdeposit',isLoggedIn,function (req,res) {
179 |         const ETHTX= require('./eth_transactions');
180 |         ETHTX.getUnconfirmedDepositTxByUsername(req.user.username,function (err,data) {
181 |             if(err) console.log(err);
182 |             res.send(data);
183 |         })
184 |     });
185 | 
186 |     app.get('/ajaxbchdeposit',isLoggedIn,function (req,res) {
187 |         const BCHTX= require('./bch_transactions');
188 |         BCHTX.getUnconfirmedDepositTxByUsername(req.user.username,function (err,data) {
189 |             if(err) console.log(err);
190 |             res.send(data);
191 |         })
192 |     });
193 | 
194 |     app.get('/ajaxethbalance',isLoggedIn,function (req,res) {
195 |         const ETHTX= require('./eth_transactions');
196 |         ETHTX.getETHBalanceByUsername(req.user.username,function (err,data) {
197 |             if(err) console.log(err);
198 |             res.send({'ethBalance':data});
199 |         })
200 |     });
201 | 
202 |     app.get('/ajaxbchbalance',isLoggedIn,function (req,res) {
203 |         const BCHTX= require('./bch_transactions');
204 |         BCHTX.getBCHBalanceByUserId(req.user.id,function (err,data) {
205 |             if(err) console.log(err);
206 |             res.send({'bchBalance':data});
207 |         })
208 |     });
209 | 
210 |     app.get('/ajaxcoinbalance',isLoggedIn,function (req,res) {
211 |         const DBService = require('./../service/db_service');
212 |         DBService.getUserByUsername(req.user.username,function (err,data) {
213 |             if(err) console.log(err);
214 |             res.send({'coinBalance':data[0].coin});
215 |         })
216 |     });
217 | 
218 |     app.get('/ajaxethtx',isLoggedIn,function (req,res) {
219 |         const ETHTX= require('./eth_transactions');
220 |         let returnTx=ETHTX.getETHTransactionByTxHash(req.query.eth_tx);
221 |         res.send(returnTx);
222 |     });
223 | 
224 |     app.get('/ajaxbchtx',isLoggedIn,function (req,res) {
225 |         const BCHTX= require('./bch_transactions');
226 |         BCHTX.getBCHTransactionByTxHash(req.query.bch_tx,function (err,data) {
227 |             res.send(data);
228 |         });
229 |     });
230 | };
231 | 
232 | // route middleware to make sure
233 | function isLoggedIn(req, res, next) {
234 | 
235 | 	// if user is authenticated in the session, carry on
236 | 	if (req.isAuthenticated())
237 | 		return next();
238 | 
239 | 	// if they aren't redirect them to the home page
240 | 	res.redirect('/');
241 | }
242 | 


--------------------------------------------------------------------------------
/app/eth_transactions.js:
--------------------------------------------------------------------------------
  1 | //Import modules
  2 | const Web3 = require("web3");
  3 | const KS = require('./../service/keystoreeth');
  4 | const HookedWeb3Provider = require("hooked-web3-provider");
  5 | const ETHCONFIG = require('./../config/ethereum');
  6 | const DBSERVICE = require('./../service/db_service');
  7 | 
  8 | 
  9 | // System variables
 10 | var web3;
 11 | var latestCheckedBlock;
 12 | var recipientAddresses;
 13 | var unconfirmedDepositTxs;
 14 | 
 15 | const withdrawLogStatus ={
 16 |     CREATED: 0,
 17 |     SUBMITTED: 2,
 18 |     MINED: 4
 19 | };
 20 | 
 21 | function initWeb3() {
 22 |     let ks = KS.getKeyStore();
 23 |     let provider = new HookedWeb3Provider({
 24 |         host: ETHCONFIG.host,
 25 |         transaction_signer: ks
 26 |     });
 27 |     web3 = new Web3(provider);
 28 |     console.log("The web3 instance was initiated successfully. It is "+web3);
 29 | }
 30 | 
 31 | function initLatestCheckedBlock() {
 32 |     DBSERVICE.getLatestETHCheckedBlock(function (err,data) {
 33 |         if(err) latestCheckedBlock = ETHCONFIG.minStartBlock;
 34 |         else {
 35 |             latestCheckedBlock= Math.max(data,ETHCONFIG.minStartBlock);
 36 |         }
 37 |         console.log("The latest checked block was initiated successfully. It is "+latestCheckedBlock);
 38 |     })
 39 | }
 40 | 
 41 | 
 42 | function initRecipientAddresses() {
 43 |     DBSERVICE.getAllUsers(function (err,data) {
 44 |         if(!err){
 45 |             let addressArray = [];
 46 |             for(let i=0;i<data.length;i++){
 47 |                 addressArray.push(data[i].eth_address);
 48 |             }
 49 |             addRecipientAddresses(addressArray);
 50 |         }else{
 51 |             console.log(err);
 52 |         }
 53 |     })
 54 | }
 55 | 
 56 | function addRecipientAddresses(addressArray) {
 57 |     if (typeof recipientAddresses !=='undefined')
 58 |         recipientAddresses = recipientAddresses.concat(addressArray);
 59 |     else recipientAddresses = addressArray;
 60 | }
 61 | 
 62 | function checkBlockChainForMinedTxService() {
 63 | 
 64 |     let latestMinedBlock = web3.eth.getBlock('latest').number;
 65 |     if((typeof recipientAddresses !=='undefined')|| (typeof latestCheckedBlock!=='undefined')|| (typeof  web3!=='undefined')){
 66 | 
 67 |         if(latestCheckedBlock>=latestMinedBlock-ETHCONFIG.minMinedRequirement){
 68 |             console.log('The lasted checked block is '+ latestMinedBlock+'. No new mined blocks........');
 69 |         }
 70 |         else
 71 |             checkDepositTxs(recipientAddresses,latestCheckedBlock+1,latestMinedBlock-ETHCONFIG.minMinedRequirement);
 72 |     }
 73 |     checkSubmittedWithdrawTxs();
 74 |     unconfirmedDepositTxs =getUnconfirmedDepositTx(recipientAddresses);
 75 | }
 76 | 
 77 | function checkDepositTxs(myaccounts, startBlockNumber, endBlockNumber) {
 78 |     if(typeof myaccounts ==='undefined')  return;
 79 | 
 80 |     if((startBlockNumber <ETHCONFIG.minStartBlock)||startBlockNumber===null) startBlockNumber=ETHCONFIG.minStartBlock;
 81 | 
 82 |     if ((endBlockNumber ===null)||(endBlockNumber<startBlockNumber)){
 83 |         endBlockNumber = web3.eth.blockNumber;
 84 |     }
 85 | 
 86 |     console.log("Searching for transactions for accounts \"" + myaccounts.toString() + "\" from block "  + startBlockNumber + " to block " + endBlockNumber);
 87 | 
 88 |     for (let i = startBlockNumber; i <= endBlockNumber; i++) {
 89 |         console.log("Searching block " + i);
 90 |         let block = web3.eth.getBlock(i, true);
 91 |         if (block !== null && block.transactions !== null) {
 92 |             block.transactions.forEach( function(transaction) {
 93 |                 if (myaccounts.indexOf(transaction.to) >= 0) {
 94 |                     DBSERVICE.getUserByEthAddress(transaction.to,function (err,users) {
 95 |                         if(err) {
 96 |                             console.log(err);
 97 |                             return;
 98 |                         }
 99 |                         let depositCoinNumber = this.transaction.value/ETHCONFIG.WeisPerCoin;
100 |                         let currentCoinNumber = users[0].coin;
101 |                         let username = users[0].username;
102 |                         DBSERVICE.updateCoinByUsername(depositCoinNumber+currentCoinNumber,username,function (err,data) {
103 |                             if(err) {
104 |                                 console.log(err);
105 |                                 return;
106 |                             }
107 |                             DBSERVICE.addETHDepositTransaction(this.transaction.hash,this.transaction.to,this.user.id,this.transaction.value/1000000000,this.transaction.blockNumber,function (err,data) {
108 |                                 if(err) {
109 |                                     console.log(err);
110 |                                     return;
111 |                                 }
112 |                                 console.log(" Find a new ETH deposit transaction. TX  is "+transaction.hash+". The recipient user id is "+this.user.id);
113 |                             }.bind({transaction:transaction,user:this.user}));
114 | 
115 |                         }.bind({transaction:transaction,user:users[0]}));
116 | 
117 |                     }.bind({transaction:transaction}));
118 |                 }
119 |             });
120 |             if(i>latestCheckedBlock)
121 |                 latestCheckedBlock=i;
122 |         }
123 |     }
124 | }
125 | 
126 | 
127 | function getUnconfirmedDepositTx(addressArray) {
128 | 
129 |     let latestMinedBlock = web3.eth.getBlock('latest').number;
130 |     let startBlock = latestMinedBlock- ETHCONFIG.minMinedRequirement;
131 |     let unconfirmedDepositTxs = [];
132 |     for(let i= startBlock;i<=latestMinedBlock;i++){
133 |         let block = web3.eth.getBlock(i, true);
134 |         block.transactions.forEach(function (tx) {
135 |             if(addressArray.indexOf(tx.to)>=0)
136 |             {
137 |                 let returnTx ={'blockHash':tx.blockHash,'eth_address':tx.to,'confirmations':latestMinedBlock-tx.blockNumber,'need':20}
138 |                 unconfirmedDepositTxs.push(returnTx)
139 |             }
140 |         });
141 |     }
142 |     return unconfirmedDepositTxs;
143 | }
144 | 
145 | function getUnconfirmedDepositTxByUsername(username,callback) {
146 |     DBSERVICE.getUserByUsername(username,function (err,data) {
147 |         if(err) return callback(err);
148 |         let latestMinedBlock = web3.eth.getBlock('latest').number;
149 |         let startBlock = latestMinedBlock- ETHCONFIG.minMinedRequirement;
150 |         let eth_address= data[0].eth_address;
151 |         let unconfirmedTx = [];
152 |         for(let i= 0;i<unconfirmedDepositTxs.length;i++){
153 |             if(eth_address===unconfirmedDepositTxs[i].eth_address)
154 |                 unconfirmedTx.push(unconfirmedDepositTxs[i]);
155 |         }
156 |         return callback(null,unconfirmedTx);
157 |     })
158 | }
159 | 
160 | function withdrawETH(username, toAddress, coinAmount,callback) {
161 |     DBSERVICE.getUserByUsername(username, function (err1, data1) {
162 |         if (err1) {
163 |             return callback(err1);
164 |         }
165 |         else {
166 |             let newCoinValue = data1[0].coin - coinAmount;
167 |             let user = data1[0];
168 |             user.coin = newCoinValue;
169 |             if (newCoinValue < 0) {
170 |                 return callback("The user " + username + " does not have enough coins to withdraw!");
171 |             }
172 |             DBSERVICE.updateCoinByUsername(newCoinValue, username, function (err2, data2) {
173 |                 if (err2) {
174 |                     return callback(err2);
175 |                 } else {
176 |                     DBSERVICE.addETHWithdrawLog(this.user.id, toAddress, coinAmount, withdrawLogStatus.CREATED, function (err3, data3) {
177 |                         if (err3)
178 |                             return callback(err3);
179 |                         else {
180 |                             sendTxToNode(data3, function (err4, data4) {
181 |                                 if (err4)
182 |                                     return callback(err4);
183 |                                 else {
184 |                                     DBSERVICE.updateETHWithdrawLogById(this.withdrawLog.id, {
185 |                                         tx_hash: data4.tx_hash,
186 |                                         tx_status: withdrawLogStatus.SUBMITTED
187 |                                     }, function (err5, data5) {
188 |                                         if (err5)
189 |                                             return callback(err5);
190 |                                         else {
191 |                                             return callback(null,data4.tx_hash);
192 |                                         }
193 |                                     });
194 |                                 }
195 |                             }.bind({withdrawLog: data3}));
196 |                         }
197 |                     });
198 |                 }
199 |             }.bind({user: data1[0]}));
200 |         }
201 |     });
202 | }
203 | 
204 | function sendTxToNode(withdrawLog, done) {
205 | 
206 |     let from = withdrawLog.from_address;
207 |     let to = withdrawLog.to_address;
208 |     let value = withdrawLog.eth_value;
209 | 
210 | 
211 |     let date = {
212 |         from: from,
213 |         to: to,
214 |         value: value,
215 |         gas: 50000,
216 |         gasPrice:web3.eth.gasPrice
217 |     }
218 | 
219 |     web3.eth.sendTransaction(date, function(error, result){
220 |         if(error)
221 |         {
222 |             return done(error);
223 |         }
224 |         else
225 |         {
226 |             withdrawLog.tx_status = withdrawLogStatus.SUBMITTED;
227 |             withdrawLog.tx_hash = result;
228 |             return done(null, withdrawLog);
229 |         }
230 |     })
231 | }
232 | 
233 | function checkSubmittedWithdrawTxs() {
234 |     let latestMinedBlock = web3.eth.getBlock('latest').number;
235 |     DBSERVICE.getETHWithdrawLogByStatus(withdrawLogStatus.SUBMITTED,function (err,rows) {
236 |         if(err)
237 |             console.log(err);
238 |         else{
239 |             for(let i=0;i<rows.length;i++) {
240 | 
241 |                 let tx = web3.eth.getTransaction(rows[i].tx_hash);
242 |                 if (tx !==null && tx.blockNumber) {
243 |                     if (tx.blockNumber < latestMinedBlock - ETHCONFIG.minMinedRequirement) {
244 |                         DBSERVICE.updateETHWithdrawLogById(rows[i].id,{tx_status:withdrawLogStatus.MINED,block_number:tx.blockNumber},function (err,date) {
245 |                             if(err)
246 |                                 console.log(err);
247 |                             else{
248 |                                 console.log("ETH Tx id "+this.row.tx_hash+" has been mined successfully!");
249 |                             }
250 |                         }.bind({row:rows[i]}))
251 | 
252 |                     }
253 |                 }
254 |             }
255 |         }
256 |     });
257 | }
258 | 
259 | function getETHBalanceByUserId(userId,done) {
260 |     DBSERVICE.getETHDepositeTxsByUserId(userId,function (err,data) {
261 |         if(err)
262 |         {
263 |             return done(err);
264 |         }
265 |         let totalWithdraw =0;
266 |         for(let i=0;i<data.length;i++){
267 |             totalWithdraw+=data[i].value;
268 |         }
269 |         DBSERVICE.getETHWithdrawTxsByUserId(userId,function (err,data) {
270 |             if(err){
271 |                 return done(err);
272 |             }
273 |             for(let j=0;j<data.length;j++){
274 |                 totalWithdraw-=data[j].eth_value;
275 |             }
276 |             return done(null,totalWithdraw);
277 |         }.bind({totalWithdraw:totalWithdraw}))
278 |     })
279 | }
280 | 
281 | function getETHBalanceByUsername(username,done) {
282 |   DBSERVICE.getUserByUsername(username,function (err,data) {
283 |       if(err) return done(err);
284 |       if(data.length!==1) return done("More than one user have this user name!");
285 |       else
286 |           getETHBalanceByUserId(data[0].id,function (err,data) {
287 |               if(err) return done(err);
288 |               return done(null,data)
289 |           });
290 |   })
291 | }
292 | 
293 | function getETHTransactionByTxHash(txid) {
294 |     let returnTx= web3.eth.getTransaction(txid);
295 |     let latestMinedBlock = web3.eth.getBlock('latest').number;
296 |     let confirmations =0;
297 |     if(returnTx.blockNumber===null) confirmations=0;
298 |     else confirmations = latestMinedBlock-returnTx.blockNumber;
299 |     let tx={
300 |         hash:txid,
301 |         to:returnTx.to,
302 |         value: returnTx.value,
303 |         confirmations: confirmations
304 |     };
305 |     return tx;
306 | }
307 | module.exports = {
308 |     init: function () {
309 |         initWeb3();
310 |         initLatestCheckedBlock();
311 |         initRecipientAddresses();
312 |     },
313 |     addRecipientAddresses: addRecipientAddresses,
314 |     checkBlockChainForMinedTxService: checkBlockChainForMinedTxService,
315 |     withdrawETH:withdrawETH,
316 |     getETHBalanceByUserId:getETHBalanceByUserId,
317 |     getUnconfirmedDepositTxByUsername:getUnconfirmedDepositTxByUsername,
318 |     getETHBalanceByUsername:getETHBalanceByUsername,
319 |     getETHTransactionByTxHash,getETHTransactionByTxHash
320 | }


--------------------------------------------------------------------------------
/service/db_service.js:
--------------------------------------------------------------------------------
  1 | const MYSQL = require('mysql');
  2 | const DBCONFIG = require('./../config/database');
  3 | const connection = MYSQL.createConnection(DBCONFIG.connection);
  4 | const BCHCONFIG = require('./../config/bchconfig');
  5 | const ETHCONFIG = require('./../config/ethereum');
  6 | 
  7 | 
  8 | function getUserByUsername(username,done) {
  9 |     connection.query("SELECT * FROM "+DBCONFIG.database+ "."+ DBCONFIG.users_table +" where username='"+username+"'", function(err, rows){
 10 |         if (err){
 11 |             return done(err);
 12 |         }
 13 |         else if(rows.length==0){
 14 |             return done("No users with this username "+username+" were found!");
 15 |         }
 16 |         else if(rows.length>1){
 17 |             return done("More than one users with this username "+username+" were found!");
 18 |         }
 19 |         return done(null, rows);
 20 |     });
 21 | }
 22 | 
 23 | function getUserByUseId(userId,done) {
 24 |     connection.query("SELECT * FROM "+DBCONFIG.database+ "."+ DBCONFIG.users_table +" where id='"+userId+"'", function(err, rows){
 25 |         if (err){
 26 |             return done(err);
 27 |         }
 28 |         else if(rows.length==0){
 29 |             return done("No users with this user id "+userId+" were found!");
 30 |         }
 31 |         else if(rows.length>1){
 32 |             return done("More than one users with this id "+userId+" were found!");
 33 |         }
 34 |         return done(null, rows);
 35 |     });
 36 | }
 37 | 
 38 | function getUserByEthAddress(eth_address,done) {
 39 |     connection.query("SELECT * FROM "+DBCONFIG.database+ "."+ DBCONFIG.users_table +" where eth_address='"+eth_address+"'", function(err, rows){
 40 |         if (err){
 41 |             return done(err);
 42 |         }
 43 |         else if(rows.length==0){
 44 |             return done("No users with this eth_address "+eth_address+" were found!");
 45 |         }
 46 |         else if(rows.length>1){
 47 |             return done("More than one users with this eth_address "+eth_address+" were found!");
 48 |         }
 49 |         return done(null, rows);
 50 |     });
 51 | }
 52 | 
 53 | 
 54 | function getAllUsers(done) {
 55 |     connection.query("SELECT * FROM "+DBCONFIG.database+ ".users", function(err, rows){
 56 |         if (err){
 57 |             return done(err);
 58 |         }
 59 |         if (rows.length===0){
 60 |             return done("No Users are found in Mysql database!");
 61 |         }
 62 |         return done(null, rows);
 63 |     });
 64 | }
 65 | 
 66 | function updateCoinByUsername(coin,username,done) {
 67 | 
 68 |     connection.query("UPDATE "+DBCONFIG.database+".users SET coin = ? WHERE username = ?",[coin, username], function(err, rows){
 69 |         if (err){
 70 |             return done(err);
 71 |         }
 72 |         return done(null,rows);
 73 |     });
 74 | }
 75 | 
 76 | function addBCHDepositTransaction(txhash,to_address,to_user_id,value,blocknumber,done) {
 77 | 
 78 |     let insertQuery = "INSERT INTO "+DBCONFIG.database+".bch_transaction ( txhash, to_address, to_user_id, value, blocknumber )" +
 79 |         " values ('"+txhash+"','"+to_address+"',"+to_user_id+","+value+","+blocknumber+")";
 80 | 
 81 |     connection.query(insertQuery, function (err, rows) {
 82 |         if(err)
 83 |             return done(err);
 84 |         else{
 85 |             return done(null, rows);
 86 |         }
 87 |     });
 88 | }
 89 | 
 90 | 
 91 | function addETHDepositTransaction(txhash,to_address,to_user_id,value,blocknumber,done) {
 92 | 
 93 |     let insertQuery = "INSERT INTO "+DBCONFIG.database+".eth_transaction ( txhash, to_address, to_user_id, value, blocknumber )" +
 94 |         " values ('"+txhash+"','"+to_address+"',"+to_user_id+","+value+","+blocknumber+")";
 95 |     connection.query(insertQuery, function (err, rows) {
 96 |         if(err){
 97 |             return done(err);
 98 |         }
 99 |         else{
100 |             return done(null, rows);
101 |         }
102 |     });
103 | }
104 | 
105 | 
106 | function getBCHDepositTransactionByTxId(txid, done) {
107 |     connection.query("SELECT * FROM "+DBCONFIG.database+ "."+DBCONFIG.bch_transaction+ " where txhash = '" +txid+"'", function(err, rows){
108 |         if (err){
109 |             return done(err);
110 |         }
111 |         return done(null, rows);
112 |     });
113 | }
114 | 
115 | function addBCHWithdrawLog(userid, toAddress, coinAmount,status,done) {
116 | 
117 |     let from_address = BCHCONFIG.withdrawSourceAccount;
118 |     let to_address = toAddress;
119 |     let to_userId = userid;
120 |     let coin_value= coinAmount;
121 |     let bch_value = 100000000*coinAmount /BCHCONFIG.coinsPerBCH;
122 |     let tx_status = status;
123 | 
124 |     let insertQuery = "INSERT INTO "+DBCONFIG.database+"."+ DBCONFIG.bch_withdraw_log+"( from_address, to_address, to_user_id, coin_value, bch_value, tx_status)" +
125 |         " values ('"+from_address+"','"+to_address+"',"+to_userId+","+coin_value+","+bch_value+","+tx_status+")";
126 | 
127 |     connection.query(insertQuery,function (err, result) {
128 |         if(err){
129 |             return done(err);
130 |         }else{
131 |             let withdrawLog = {
132 |                 id:result.insertId,
133 |                 from_address: from_address,
134 |                 to_address:to_address,
135 |                 to_userId: to_userId,
136 |                 coin_value: coin_value,
137 |                 bch_value: bch_value,
138 |                 tx_status: tx_status
139 |             };
140 |             return done(null,withdrawLog );
141 |         }
142 |     })
143 | 
144 | }
145 | 
146 | 
147 | 
148 | function addETHWithdrawLog(userid, toAddress, coinAmount,status,done) {
149 | 
150 |     let from_address = ETHCONFIG.withdrawSourceAccount;
151 |     let to_address = toAddress;
152 |     let to_userId = userid;
153 |     let coin_value = coinAmount;
154 |     let eth_value = coinAmount*ETHCONFIG.WeisPerCoin/1000000000;
155 |     let tx_status = status;
156 | 
157 |     let insertQuery = "INSERT INTO "+DBCONFIG.database+"."+ DBCONFIG.eth_withdraw_log+"( from_address, to_address, to_user_id, coin_value, eth_value, tx_status)" +
158 |         " values ('"+from_address+"','"+to_address+"',"+to_userId+","+coin_value+","+eth_value+","+tx_status+")";
159 | 
160 |     connection.query(insertQuery,function (err, result) {
161 |         if(err){
162 |             return done(err);
163 |         }else{
164 |             let withdrawLog = {
165 |                 id:result.insertId,
166 |                 from_address: from_address,
167 |                 to_address:to_address,
168 |                 to_userId: to_userId,
169 |                 coin_value: coin_value,
170 |                 eth_value: eth_value,
171 |                 tx_status: tx_status
172 |             };
173 |             return done(null,withdrawLog );
174 |         }
175 |     })
176 | 
177 | }
178 | 
179 | function updateBCHWithdrawLogById(id,list,done) {
180 |     let keys = Object.keys(list);
181 |     let values = Object.values(list);
182 |     let setString = 'set ';
183 |     for(let i=0; i<keys.length; i++){
184 |         if(typeof values[i]==='string')
185 |             setString = setString + keys[i]+"='"+values[i]+"'";
186 |         else
187 |             setString = setString + keys[i]+"="+values[i];
188 |         if(i!==keys.length-1) setString= setString+', ';
189 |     }
190 |     let updateQuery = "UPDATE "+DBCONFIG.database+"."+ DBCONFIG.bch_withdraw_log+" "+setString+" WHERE id ="+id;
191 | 
192 |     connection.query(updateQuery,function (err, rows) {
193 |         if (err) {
194 |             return done(err);
195 |         }
196 |         return done(null, rows);
197 |     });
198 | }
199 | 
200 | 
201 | function updateETHWithdrawLogById(id,list,done) {
202 |     let keys = Object.keys(list);
203 |     let values = Object.values(list);
204 |     let setString = 'set ';
205 |     for(let i=0; i<keys.length; i++){
206 |         if(typeof values[i]==='string')
207 |             setString = setString + keys[i]+"='"+values[i]+"'";
208 |         else
209 |             setString = setString + keys[i]+"="+values[i];
210 |         if(i!==keys.length-1) setString= setString+', ';
211 |     }
212 |     let updateQuery = "UPDATE "+DBCONFIG.database+"."+ DBCONFIG.eth_withdraw_log+" "+setString+" WHERE id ="+id;
213 | 
214 |     connection.query(updateQuery,function (err, rows) {
215 |         if (err) {
216 |             return done(err);
217 |         }
218 |         return done(null, rows);
219 |     });
220 | }
221 | 
222 | function updateETHWithdrawLogById(id,list,done) {
223 |     let keys = Object.keys(list);
224 |     let values = Object.values(list);
225 |     let setString = 'set ';
226 |     for(let i=0; i<keys.length; i++){
227 |         if(typeof values[i]==='string')
228 |             setString = setString + keys[i]+"='"+values[i]+"'";
229 |         else
230 |             setString = setString + keys[i]+"="+values[i];
231 |         if(i!==keys.length-1) setString= setString+', ';
232 |     }
233 |     let updateQuery = "UPDATE "+DBCONFIG.database+"."+ DBCONFIG.eth_withdraw_log+" "+setString+" WHERE id ="+id;
234 | 
235 |     connection.query(updateQuery,function (err, rows) {
236 |         if (err) {
237 |             return done(err);
238 |         }
239 |         return done(null, rows);
240 |     });
241 | }
242 | 
243 | function updateUsersById(id,list,done) {
244 |     let keys =Object.keys(list);
245 |     let values = Object.values(list);
246 |     let setString = 'set ';
247 |     for(let i=0; i<keys.length; i++){
248 |         if(typeof values[i]==='string')
249 |             setString = setString + keys[i]+"='"+values[i]+"'";
250 |         else
251 |             setString = setString + keys[i]+"="+values[i];
252 |         if(i!==keys.length-1) setString= setString+', ';
253 |     }
254 |     let updateQuery = "UPDATE "+DBCONFIG.database+"."+ DBCONFIG.users_table+" "+setString+" WHERE id ="+id;
255 |     connection.query(updateQuery,function (err, rows) {
256 |         if (err) {
257 |             return done(err);
258 |         }
259 |         return done(null, rows);
260 |     });
261 | };
262 | 
263 | 
264 | function updateUsersByUsername(username,list,done) {
265 |     let keys =Object.keys(list);
266 |     let values = Object.values(list);
267 |     let setString = 'set ';
268 |     for(let i=0; i<keys.length; i++){
269 |         if(typeof values[i]==='string')
270 |             setString = setString + keys[i]+"='"+values[i]+"'";
271 |         else
272 |             setString = setString + keys[i]+"="+values[i];
273 |         if(i!==keys.length-1) setString= setString+', ';
274 |     }
275 |     let updateQuery = "UPDATE "+DBCONFIG.database+"."+ DBCONFIG.users_table+" "+setString+" WHERE username ='"+username+"'";
276 |     connection.query(updateQuery,function (err, rows) {
277 |         if (err) {
278 |             return done(err);
279 |         }
280 |         return done(null, rows);
281 |     });
282 | };
283 | 
284 | function getBCHWithdrawLogByStatus(status,done) {
285 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.bch_withdraw_log+" WHERE tx_status ="+status;
286 | 
287 |     connection.query(selectQuery,function (err, rows) {
288 |         if (err) {
289 |             return done(err);
290 |         }
291 |         return done(null, rows);
292 |     });
293 | }
294 | 
295 | function getETHWithdrawLogByStatus(status,done) {
296 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.eth_withdraw_log+" WHERE tx_status ="+status;
297 | 
298 |     connection.query(selectQuery,function (err, rows) {
299 |         if (err) {
300 |             return done(err);
301 |         }
302 |         return done(null, rows);
303 |     });
304 | }
305 | 
306 | function getLatestETHCheckedBlock(done) {
307 |     connection.query("SELECT MAX(blocknumber) as max_blocknumber FROM "+DBCONFIG.database+ ".eth_transaction", function(err, rows){
308 |         if (err){
309 |             return done(err);
310 |         }
311 |         if (rows.length == 0){
312 |             return done("No transactions were found in database!");
313 |         }
314 |         // all is well, return successful user
315 |         return done(null, rows[0].max_blocknumber);
316 |     });
317 | };
318 | 
319 | function getETHDepositeTxsByUserId(userId,done){
320 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.ethereum_transaction+" WHERE to_user_id ="+userId;
321 | 
322 |     connection.query(selectQuery,function (err, rows) {
323 |         if (err) {
324 |             return done(err);
325 |         }
326 |         return done(null, rows);
327 |     });
328 | }
329 | 
330 | function getETHWithdrawTxsByUserId(userId,done){
331 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.eth_withdraw_log+" WHERE to_user_id ="+userId;
332 | 
333 |     connection.query(selectQuery,function (err, rows) {
334 |         if (err) {
335 |             return done(err);
336 |         }
337 |         return done(null, rows);
338 |     });
339 | }
340 | 
341 | function getBCHDepositeTxsByUserId(userId,done){
342 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.bch_transaction+" WHERE to_user_id ="+userId;
343 |     connection.query(selectQuery,function (err, rows) {
344 |         if (err) {
345 |             return done(err);
346 |         }
347 |         return done(null, rows);
348 |     });
349 | }
350 | 
351 | function getBCHWithdrawTxsByUserId(userId,done){
352 |     let selectQuery = "select * from "+DBCONFIG.database+"."+ DBCONFIG.bch_withdraw_log+" WHERE to_user_id ="+userId;
353 |     connection.query(selectQuery,function (err, rows) {
354 |         if (err) {
355 |             return done(err);
356 |         }
357 |         return done(null, rows);
358 |     });
359 | }
360 | 
361 | module.exports = {
362 |     getUserByUsername: getUserByUsername,
363 |     updateCoinByUsername: updateCoinByUsername,
364 |     addBCHDepositTransaction:addBCHDepositTransaction,
365 |     getBCHDepositTransactionByTxId:getBCHDepositTransactionByTxId,
366 |     addBCHWithdrawLog:addBCHWithdrawLog,
367 |     updateBCHWithdrawLogById:updateBCHWithdrawLogById,
368 |     updateUsersById:updateUsersById,
369 |     getBCHWithdrawLogByStatus:getBCHWithdrawLogByStatus,
370 |     getAllUsers:getAllUsers,
371 |     getETHWithdrawLogByStatus:getETHWithdrawLogByStatus,
372 |     getLatestETHCheckedBlock:getLatestETHCheckedBlock,
373 |     updateETHWithdrawLogById:updateETHWithdrawLogById,
374 |     updateUsersByUsername:updateUsersByUsername,
375 |     getUserByEthAddress:getUserByEthAddress,
376 |     addETHDepositTransaction:addETHDepositTransaction,
377 |     addETHWithdrawLog:addETHWithdrawLog,
378 |     getETHDepositeTxsByUserId:getETHDepositeTxsByUserId,
379 |     getETHWithdrawTxsByUserId:getETHWithdrawTxsByUserId,
380 |     getBCHDepositeTxsByUserId:getBCHDepositeTxsByUserId,
381 |     getBCHWithdrawTxsByUserId:getBCHWithdrawTxsByUserId,
382 |     getUserByUseId:getUserByUseId
383 | };
384 | 


--------------------------------------------------------------------------------
/service/bitcoincashrpc.js:
--------------------------------------------------------------------------------
  1 | let translate = require('npm-address-translator');
  2 | let axios = require('axios');
  3 | 
  4 | class BitcoinCashRPC {
  5 |   constructor(host, username, password, port, timeout) {
  6 |     this.host = host;
  7 |     this.username = username;
  8 |     this.password = password;
  9 |     this.port = port;
 10 |     this.timeout = timeout;
 11 | 
 12 |     //this.instance = axios.create({})
 13 |   }
 14 | 
 15 |   /**
 16 |    * @param  {String} Method  name of the method being called
 17 |    * @param  {Array}  params  various number of arguments based on method
 18 |    * @return {String} body    the plaintext body to POST
 19 |    */
 20 |   async buildBody(method, ...params) {
 21 |     var time = Date.now();
 22 | 
 23 |     let body = {
 24 |       jsonrpc: '1.0',
 25 |       id: time,
 26 |       method: method
 27 |     };
 28 | 
 29 |     if (params.length) {
 30 |       body.params = params;
 31 |     }
 32 | 
 33 |     return JSON.stringify(body);
 34 |   }
 35 | 
 36 |   /**
 37 |    * @param  {String} Method  name of the method
 38 |    * @param  {...[type]} params   varies based on the method
 39 |    * @return {String} Header  plaintext request object to POST to the node
 40 |    */
 41 |   async performMethod(method, ...params) {
 42 |     if (params.length) {
 43 |       var body = await this.buildBody(method.toLowerCase(), ...params);
 44 |     } else {
 45 |       var body = await this.buildBody(method.toLowerCase());
 46 |     }
 47 |     let req = {
 48 |       method: 'POST',
 49 |       url: `http://${this.host}:${this.port}/`,
 50 |       auth: { username: `${this.username}`, password: `${this.password}` },
 51 |       headers: {
 52 |         'Content-Type': 'text/plain'
 53 |       },
 54 |       timeout: `${this.timeout}`,
 55 |       data: `${body}`
 56 |     };
 57 |     return req;
 58 |   }
 59 |   /**
 60 |    * @return estimated transaction fee with parameter for number of blocks
 61 |    */
 62 |   async estimateSmartFee(...params) {
 63 |     let req = await this.performMethod('estimateSmartFee', ...params);
 64 |     return axios(req)
 65 |       .then(response => {
 66 |         return response.data.result;
 67 |       })
 68 |       .catch(err => {
 69 |         console.log('failed in estimateSmartFee', err.response.data);
 70 |       });
 71 |   }
 72 |   /**
 73 |    * @return {Object} array of all transactions incoming/outgoing
 74 |    */
 75 |   async listTransactions(...params) {
 76 |     let req = await this.performMethod('listTransactions', ...params);
 77 | 
 78 |     return axios(req)
 79 |       .then(response => {
 80 |         return response.data.result;
 81 |       })
 82 |       .catch(err => {
 83 |         console.log('failed in listTransactions', err.response.data);
 84 |       });
 85 |   }
 86 | 
 87 | 
 88 |     async sendRawTransaction(...params) {
 89 |         let req = await this.performMethod('sendrawtransaction', ...params);
 90 | 
 91 |         return axios(req)
 92 |             .then(response => {
 93 |                 return response.data.result;
 94 |             })
 95 |             .catch(err => {
 96 |                 console.log('failed in sendrawtransaction', err.response.data);
 97 |             });
 98 |     }
 99 | 
100 |     /**
101 |      * @return {Object} array of all unspent transactions
102 |      */
103 |     async listUnspent(...params) {
104 |         let req = await this.performMethod('listunspent', ...params);
105 | 
106 |         return axios(req)
107 |             .then(response => {
108 |                 return response.data.result;
109 |             })
110 |             .catch(err => {
111 |                 console.log('failed in listunspent', err.response.data);
112 |             });
113 |     }
114 | 
115 |   /**
116 |    * @return {Object} array   version, walletversion, balance, block height, difficulty, tx fee
117 |    */
118 |   async getInfo() {
119 |     let req = await this.performMethod('getInfo');
120 | 
121 |     return axios(req)
122 |       .then(response => {
123 |         return response.data.result;
124 |       })
125 |       .catch(err => {
126 |         console.log('failed in getInfo', err.response.data);
127 |       });
128 |   }
129 |   /**
130 |    * @return {string} height   latest confirmed block number
131 |    */
132 |   async getBlockCount() {
133 |     let req = await this.performMethod('getBlockCount');
134 | 
135 |     return axios(req)
136 |       .then(response => {
137 |         return response.data.result;
138 |       })
139 |       .catch(err => {
140 |         console.log('failed in getBlockCount', err.response.data);
141 |       });
142 |   }
143 | 
144 |   /**
145 |    * @return {Object} array   wallet version, balance, unconfirmed balance, txcount, and what the tx fee was set at
146 |    */
147 |   async getWalletInfo() {
148 |     let req = await this.performMethod('getWalletInfo');
149 | 
150 |     return axios(req)
151 |       .then(response => {
152 |         return response.data.result;
153 |       })
154 |       .catch(err => {
155 |         console.log('failed in getWalletInfo', err.response.data);
156 |       });
157 |   }
158 | 
159 |   /**
160 |    * @return {String} balance   In satoshis
161 |    */
162 |   async getUnconfirmedBalance() {
163 |     let req = await this.performMethod('getUnconfirmedBalance');
164 | 
165 |     return axios(req)
166 |       .then(response => {
167 |         return response.data.result;
168 |       })
169 |       .catch(err => {
170 |         console.log('failed in getUnconfirmedBalance', err.response.data);
171 |       });
172 |   }
173 | 
174 |   /**
175 |    * @return {String} balance  in satoshis
176 |    */
177 |   async getWalletInfo() {
178 |     let req = await this.performMethod('getWalletInfo');
179 | 
180 |     return axios(req)
181 |       .then(response => {
182 |         return response.data.result;
183 |       })
184 |       .catch(err => {
185 |         console.log('failed in getWalletInfo', err.response.data);
186 |       });
187 |   }
188 | 
189 |   /**
190 |    * @param  {Number}  blocknumber  block number you want the hash of
191 |    * @return {String}  blockhash
192 |    */
193 |   async getBlockHash(...params) {
194 |     let req = await this.performMethod('getBlockHash', ...params);
195 | 
196 |     return axios(req)
197 |       .then(response => {
198 |         return response.data.result;
199 |       })
200 |       .catch(err => {
201 |         console.log('failed in getBlockHash', err.response.data);
202 |       });
203 |   }
204 | 
205 |   /**
206 |    * @param  {String}  account  name of account for new address
207 |    * @return {String}  address
208 |    */
209 |   async getNewAddress(...params) {
210 |     let req = await this.performMethod('getNewAddress', ...params);
211 | 
212 |     return axios(req)
213 |       .then(response => {
214 |         return response.data.result;
215 |       })
216 |       .catch(err => {
217 |         console.log('failed in getNewAddress', err.response.data);
218 |       });
219 |   }
220 |   /**
221 |    * @param {String} transaction id
222 |    * @return {String} transaction details
223 |    */
224 |   async getTransaction(...params) {
225 |     let req = await this.performMethod('getTransaction', ...params);
226 | 
227 |     return axios(req)
228 |       .then(response => {
229 |         return response.data.result;
230 |       })
231 |       .catch(err => {
232 |         console.log('failed in getTransaction', err.response.data);
233 |       });
234 |   }
235 |   /**
236 |    * @param {String}  account name of the account
237 |    * @return {String} balance  in satoshis
238 |    */
239 |   async getBalance(...params) {
240 |     let req = await this.performMethod('getBalance', ...params);
241 | 
242 |     return axios(req)
243 |       .then(response => {
244 |         return response.data.result;
245 |       })
246 |       .catch(err => {
247 |         console.log('failed in getBalance', err.response.data);
248 |       });
249 |   }
250 | 
251 |   /**
252 |    * @param {Number} TxFee transaction fee
253 |    * @return {Boolean} whether it was successful
254 |    */
255 |   async setTxFee(...params) {
256 |     let req = await this.performMethod('setTxFee', ...params);
257 | 
258 |     return axios(req)
259 |       .then(response => {
260 |         return response.data.result;
261 |       })
262 |       .catch(err => {
263 |         console.log('failed in setTxFee', err.response.data);
264 |       });
265 |   }
266 | 
267 |   /**
268 |    * @param  {String} Address   bitcoin address to be checked
269 |    * @return {Boolean}          whether address is valid
270 |    */
271 |   async validateAddress(...params) {
272 |     if (!this.isValidAddress(...params)) {
273 |       console.log('failed valid check');
274 |       return 'invalid address given';
275 |     }
276 | 
277 |     let req = await this.performMethod('validateAddress', ...params);
278 | 
279 |     return axios(req)
280 |       .then(response => {
281 |         return response.data.result;
282 |       })
283 |       .catch(err => {
284 |         console.log('failed in validateAddress', err.response.data);
285 |       });
286 |   }
287 | 
288 |   /**
289 |      * @param  {String} Address   bitcoin address to send to
290 |      * @param {Number} Amount     number of bitcoin to send
291 |      * @return {String} Tx        returns the transaction ID
292 |      */
293 |     async sendToAddress(...params) {
294 |         if (!this.isValidAddress(...params)) {
295 |             console.log('failed valid check');
296 |             return 'invalid address given';
297 |         }
298 | 
299 |         let req = await this.performMethod('sendToAddress', ...params);
300 | 
301 |         return axios(req)
302 |             .then(response => {
303 |                 return response.data.result;
304 |             })
305 |             .catch(err => {
306 |                 console.log('failed in sendToAddress', err);
307 |                 return err.message;
308 |             });
309 |     }
310 | 
311 |     /**
312 |      * @param  {String} Address   bitcoin address to send to
313 |      * @param {String} (string, optional, default="") An optional label
314 |      * @param resca     (boolean, optional, default=true) Rescan the wallet for transactions
315 |      * @param p2sh      (boolean, optional, default=false) Add the P2SH version of the script as well
316 |      * @return none
317 |      */
318 |     async setaccount(...params) {
319 |         /*if (!this.isValidAddress(...params)) {
320 |             console.log('failed valid check');
321 |             return 'invalid address given';
322 |         }*/
323 | 
324 |         let req = await this.performMethod('setaccount', ...params);
325 | 
326 |         return axios(req)
327 |             .then(response => {
328 |                 return response.data.result;
329 |             })
330 |             .catch(err => {
331 |                 console.log('failed in setaccount', err);
332 |                 return err.message;
333 |             });
334 |     }
335 | 
336 | 
337 |     async importaddress(...params) {
338 |         /*if (!this.isValidAddress(...params)) {
339 |             console.log('failed valid check');
340 |             return 'invalid address given';
341 |         }*/
342 | 
343 |         let req = await this.performMethod('importaddress', ...params);
344 | 
345 |         return axios(req)
346 |             .then(response => {
347 |                 return response.data.result;
348 |             })
349 |             .catch(err => {
350 |                 console.log('failed in importaddress', err);
351 |                 return err.message;
352 |             });
353 |     }
354 | 
355 |   /**
356 |    * @param  {String} account   bitcoind account to send from
357 |    * @param  {String} address   bitcoin address to send to
358 |    * @param {Number} Amount     number of bitcoin to send
359 |    * @return {String} Tx        returns the transaction ID
360 |    */
361 |   async sendFrom(...params) {
362 |     if (!this.isValidAddress(params[1])) {
363 |       console.log('failed valid check');
364 |       return 'invalid address given';
365 |     }
366 | 
367 |     let req = await this.performMethod('sendFrom', ...params);
368 | 
369 |     return axios(req)
370 |       .then(response => {
371 |         return response.data.result;
372 |       })
373 |       .catch(err => {
374 |         console.log('failed in sendFrom', err);
375 |         return err.message;
376 |       });
377 |   }
378 | 
379 |   /**
380 |    * @param  {String} accountName name of account you want the address for
381 |    * @return {String} address       returns the address
382 |    */
383 |   async getAccountAddress(...params) {
384 |     let req = await this.performMethod('getAccountAddress', ...params);
385 | 
386 |     return axios(req)
387 |       .then(response => {
388 |         return response.data.result;
389 |       })
390 |       .catch(err => {
391 |         console.log('failed in getAccountAddress', err);
392 |         return err.message;
393 |       });
394 |   }
395 |   /**
396 |    * @param  {String} blockhash
397 |    * @return {obj} data       returns the block info
398 |    */
399 |   async getBlock(...params) {
400 |     if (!this.isValidAddress(...params)) {
401 |       console.log('failed valid check');
402 |       return 'invalid address given';
403 |     }
404 | 
405 |     let req = await this.performMethod('getBlock', ...params);
406 | 
407 |     return axios(req)
408 |       .then(response => {
409 |         return response.data.result;
410 |       })
411 |       .catch(err => {
412 |         console.log('failed in getBlock', err);
413 |         return err.message;
414 |       });
415 |   }
416 | 
417 |   /**
418 |    * @param  {String} transaction_id
419 |    * @param {Number} vout     use 1
420 |    * @return {obj} data       returns the tx info
421 |    */
422 |   async getTxOut(...params) {
423 |     if (!this.isValidAddress(...params)) {
424 |       console.log('failed valid check');
425 |       return 'invalid address given';
426 |     }
427 | 
428 |     let req = await this.performMethod('getTxOut', ...params);
429 | 
430 |     return axios(req)
431 |       .then(response => {
432 |         return response.data.result;
433 |       })
434 |       .catch(err => {
435 |         console.log('failed in getTxOut', err);
436 |         return err.message;
437 |       });
438 |   }
439 | 
440 |   isValidAddress(...x) {
441 |     console.log("Valid address "+x);
442 |     const test = '[13CH][a-km-zA-HJ-NP-Z0-9]{30,33}';
443 |     const cashRegEx = /^((?:bitcoincash):)?(?:[023456789acdefghjklmnpqrstuvwxyz]){42}$/gi;
444 |     let testRegEx = new RegExp(test, 'i');
445 | 
446 |     if (testRegEx.test(x)) {
447 |       return testRegEx.test(x);
448 |     } else {
449 |       return cashRegEx.test(x);
450 |     }
451 |   }
452 | 
453 |   translateAddress(address) {
454 |     let test = '[13CH][a-km-zA-HJ-NP-Z0-9]{30,33}';
455 |     let testRegEx = new RegExp(test, 'i');
456 |     if (testRegEx.test(address)) {
457 |       let translated = translate.translateAddress(address);
458 |       if (translated.origCoin == 'BTC') {
459 |         return translated.origAddress;
460 |       } else {
461 |         return translated.resultAddress;
462 |       }
463 |     }
464 |   }
465 | }
466 | 
467 | module.exports = BitcoinCashRPC;
468 | 


--------------------------------------------------------------------------------
/app/bch_transactions.js:
--------------------------------------------------------------------------------
  1 | //Import modules
  2 | const MYSQL = require('mysql');
  3 | const BCC = require("./../service/bitcoincashrpc");
  4 | const BCHCONFIG = require('./../config/bchconfig');
  5 | const BCHADDR = require('bchaddrjs');
  6 | const DBSERVICE = require('./../service/db_service');
  7 | const BCHkeyStore = require('./../service/keystorebch');
  8 | 
  9 | 
 10 | // System variables
 11 | const BCHRPCCLIENT = new BCC(BCHCONFIG.host, BCHCONFIG.username, BCHCONFIG.password, BCHCONFIG.port, 30000);//Bitcoin Cash RPC Connection
 12 | 
 13 | //All the unspent transactions that belong to the withdraw source account.
 14 | var unspentTxs =[];
 15 | 
 16 | const withdrawLogStatus ={
 17 |     CREATED: 0,
 18 |     SUBMITTED: 2,
 19 |     MINED: 4
 20 | };
 21 | 
 22 | function addRecipientAddresses(addressArray,callback) {
 23 |     const bitcorecash = require('bitcoincashjs');
 24 |     const BASE58CHECK = bitcorecash.encoding.Base58Check;
 25 |     let count =0;
 26 |     for(let i=0;i<addressArray.length;i++){
 27 |         if (addressArray[i].bch_address===null) continue;
 28 |         let addressBase58Check;
 29 |         if(BCHCONFIG.network===bitcorecash.Networks.testnet) {
 30 |             console.log(addressArray[i].bch_address);
 31 |             console.log("6f" + addressArray[i].bch_address.slice(2));
 32 |             addressBase58Check = BASE58CHECK.encode(new Buffer.from("6f" + addressArray[i].bch_address.slice(2), "hex"));
 33 |         }
 34 |         else if(BCHCONFIG.network===bitcorecash.Networks.livenet){
 35 |             addressBase58Check = BASE58CHECK.encode(new Buffer("00"+addressArray[i].bch_address.slice(2),'hex'));
 36 |         }
 37 |         var p = Promise.resolve(BCHRPCCLIENT.importaddress(addressBase58Check.toString(),addressArray[i].username,false));
 38 |         p.then(function () {
 39 |             count++;
 40 |         });
 41 |     }
 42 |     if(count===0)
 43 |         return callback('No BCH Address has been added to the node to watch.');
 44 |     return callback(null, count);
 45 | };
 46 | 
 47 | function initRecipientAddresses() {
 48 |     DBSERVICE.getAllUsers(function (err, addressArray) {
 49 |         if(!err){
 50 |             addRecipientAddresses(addressArray,function (err, data) {
 51 |                 if(err) console.log(err)
 52 |                 else console.log(data+" BCH addresses has been added to the Bitcoin Cash Node to watch for the deposit transactions!");
 53 |             });
 54 |         }else{
 55 |             console.log(err);
 56 |         }
 57 |     });
 58 | };
 59 | 
 60 | function checkBlockChainForDepositTx() {
 61 |     if((typeof  BCHRPCCLIENT!='undefined')){
 62 |         let promise = Promise.resolve(BCHRPCCLIENT.getBlockCount());
 63 |         promise.then(function (blockAcount) {
 64 |             DBSERVICE.getAllUsers( function (err,data) {
 65 |                 if(err){
 66 |                     console.log(err);
 67 |                 }else{
 68 |                     for(let i =0;i <data.length; i++){
 69 |                       //  var username =data[i].username;
 70 |                        // var userId = data[i].id;
 71 |                        // var coinBalance = data[i].coin;
 72 |                         var p = Promise.resolve(BCHRPCCLIENT.listTransactions(data[i].username,50,0,true));
 73 |                         p.then(function (transactions) {
 74 |                             for(let j=0;j<transactions.length;j++){
 75 |                                 DBSERVICE.getBCHDepositTransactionByTxId(transactions[j].txid,function (err1, rows1) {
 76 |                                     if(err1)
 77 |                                     {
 78 |                                         console.log(err1);
 79 |                                     }
 80 |                                     else if(rows1.length==0){
 81 |                                         if((this.transaction.confirmations>=BCHCONFIG.minConfirmation)&& (this.transaction.category ==='receive')&&this.transaction.account===this.user.username)
 82 |                                         {
 83 |                                             let coinsDeposit = this.transaction.amount*BCHCONFIG.coinsPerBCH;
 84 |                                             let coinBalance = this.user.coin;
 85 |                                             var coinBalanceNew = coinBalance + coinsDeposit;
 86 |                                             console.log('coinBalanceNew is'+coinBalanceNew);
 87 |                                             console.log('username is'+this.user.username);
 88 | 
 89 |                                             DBSERVICE.updateCoinByUsername(coinBalanceNew,this.user.username,function (err3, rows3) {
 90 |                                                 if(err3)
 91 |                                                     console.log(err3);
 92 |                                                 else{
 93 |                                                     let bch_value_satoshi =this.transaction.amount*100000000;
 94 | 
 95 |                                                     DBSERVICE.addBCHDepositTransaction(this.transaction.txid,this.transaction.
 96 |                                                             address,this.user.id,bch_value_satoshi,blockAcount-this.transaction.confirmations,
 97 |                                                         function (err4, rows4) {
 98 |                                                             if(err4)
 99 |                                                                 console.log(err4);
100 |                                                             else{
101 |                                                                 console.log("Found a new BCH deposit transaction and updated all the records accordingly!");
102 |                                                                 console.log("Txid is "+this.transaction.txid);
103 |                                                             }
104 |                                                         }.bind({transaction: this.transaction,user:this.user}));
105 | 
106 |                                                 }
107 |                                             }.bind({transaction: this.transaction,user:this.user}));
108 |                                         }
109 |                                     }
110 |                                     else
111 |                                         console.log("The transaction "+this.transaction.txid+" has already been handled by the system.");
112 |                                 }.bind({transaction: transactions[j],user:this.user}));
113 |                             }
114 |                         }.bind({user:data[i]}));
115 |                     }
116 |                 }
117 |             });
118 |         });
119 | 
120 |     }
121 | };
122 | 
123 | /*
124 | This function will subtract a certain amount of Coin and send User BCH instead.
125 |  username: who asks to withdraw BCH.
126 |  toAddress: The address that the user input to receive BCH for this request. It is legacy format.
127 |  coinAmount: Coin to subtract from the user's account
128 |  For example:
129 |  withdrawBCH('8','mhREfUGuqNTpQSuPVG234kt6T9hzVYkD8Y',5000000);
130 | */
131 | function withdrawBCH(username, toAddress, coinAmount,callback) {
132 |     DBSERVICE.getUserByUsername(username, function (err1, data1) {
133 |         if (err1) {
134 |             return callback(err1);
135 |         }
136 |         else {
137 |             var newCoinValue = data1[0].coin - coinAmount;
138 |             var user = data1[0];
139 |             user.coin = newCoinValue;
140 |             if (newCoinValue < 0) {
141 |                 return callback("The user " + username + " does not have enough coins to withdraw!");
142 |             }
143 |             DBSERVICE.updateCoinByUsername(newCoinValue, username, function (err2, data2) {
144 |                 if (err2) {
145 |                     return callback(err2);
146 |                 } else {
147 |                     DBSERVICE.addBCHWithdrawLog(this.user.id, toAddress, coinAmount, withdrawLogStatus.CREATED, function (err3, data3) {
148 |                         if (err3)
149 |                             return callback(err3);
150 |                         else {
151 |                             sendTxToNode(data3, function (err4, data4) {
152 |                                 if (err4)
153 |                                     return callback(err4);
154 |                                 else {
155 |                                     DBSERVICE.updateBCHWithdrawLogById(this.withdrawLog.id, {
156 |                                         tx_hash: data4,
157 |                                         tx_status: withdrawLogStatus.SUBMITTED
158 |                                     }, function (err5, data5) {
159 |                                         if (err5)
160 |                                             return callback(err5);
161 |                                         else {
162 |                                             return callback(null,data4);
163 |                                         }
164 |                                     });
165 |                                 }
166 |                             }.bind({withdrawLog: data3}));
167 |                         }
168 |                     });
169 |                 }
170 |             }.bind({user: data1[0]}));
171 |         }
172 |     });
173 | }
174 | function sendTxToNode(withdrawLog, done) {
175 |         var bch = require('bitcoincashjs');
176 |         var bchkey = require('./../service/keystorebch');
177 |         updateUnspentTx();
178 |         var bch_value_bch = withdrawLog.coin_value / BCHCONFIG.coinsPerBCH;
179 |         var bch_value_satoshi = 100000000*withdrawLog.coin_value / BCHCONFIG.coinsPerBCH;
180 |         var withdrawUTXO =chooseUnspentTxForWithdraw(bch_value_bch);
181 |         if(withdrawUTXO.err){
182 |             return done(withdrawUTXO.err);
183 |         }else{
184 |             //The current rpc interface only accepts legacy address format, not Bitcoin cash format. We have to convert the address format before we spend these UTXOs.
185 |             //bchaddrjs does not accept bchreg prefix, convert bchreg into regtest if it is necessary.
186 |             for(var i=0; i<withdrawUTXO.UTXOs.length; i++){
187 |      //           withdrawUTXO.UTXOs[i].address.replace('bchreg','regtest');
188 |                 withdrawUTXO.UTXOs[i].address = BCHADDR.toLegacyAddress(withdrawUTXO.UTXOs[i].address);
189 |             }
190 | 
191 |             var transaction = new bch.Transaction();
192 |             transaction.from(withdrawUTXO.UTXOs);
193 |             console.log('The input address is '+withdrawUTXO.UTXOs[0].address);
194 |             transaction.to(withdrawLog.to_address, bch_value_satoshi);
195 |             transaction.change(bchkey.withdrawSource[0].address);
196 |             transaction.sign(BCHkeyStore.withdrawSource[0].derivedPrivateKey.privateKey);
197 | 
198 |             var p =  Promise.resolve(BCHRPCCLIENT.sendRawTransaction (transaction.serialize()));
199 |             p.then(info=>{
200 |                 return done(null,info);
201 |             });
202 |         }
203 |     };
204 | 
205 | function updateUnspentTx(){
206 | 
207 |     var BCHKeyStore = require('./../service/keystorebch');
208 |     if(BCHKeyStore.withdrawSource.length===0)
209 |         BCHKeyStore.setWithdrawSource();
210 |     var addresses =[];
211 |     for (var i=0; i<BCHKeyStore.withdrawSource.length;i++){
212 |         addresses.push(BCHKeyStore.withdrawSource[i].address.toString());
213 |     }
214 |     var p = Promise.resolve(BCHRPCCLIENT.listUnspent(BCHCONFIG.minConfirmation,99999999,addresses,false));
215 |     p.then(info=>{
216 |         unspentTxs = info;
217 |         console.log("Retrieve unspent transaction list for withdraw source.")
218 |     });
219 | 
220 | };
221 | 
222 | function chooseUnspentTxForWithdraw(withdrawAmount) {
223 |     var withdrawFrom = [];
224 |     for(var i=0; i<unspentTxs.length; i++){
225 |             withdrawFrom.push(unspentTxs[i])
226 |             withdrawFrom.sort(function (a,b) {
227 |                 return(a.amount-b.amount);
228 |             });
229 |     }
230 |     var totalAmount =0;
231 |     var j=0;
232 |     for(j=0; j<withdrawFrom.length; j++){
233 |         totalAmount += withdrawFrom[j].amount;
234 |         if(totalAmount>withdrawAmount+BCHCONFIG.minTxFee) {
235 |             withdrawFrom = withdrawFrom.slice(0,j+1);
236 |             return({err:null,UTXOs:withdrawFrom});
237 |         }
238 |     }
239 |     return ({err:"The account balance is insufficient."});
240 | };
241 | 
242 | function updateSubmittedWithdrawTxs() {
243 |     let promise = Promise.resolve(BCHRPCCLIENT.getBlockCount());
244 |     promise.then(function (blockAccount) {
245 |         DBSERVICE.getBCHWithdrawLogByStatus(withdrawLogStatus.SUBMITTED,function (err,rows) {
246 |             if(err)
247 |                 console.log(err);
248 |             else{
249 |                 for(var i=0;i<rows.length;i++){
250 |                     var p= Promise.resolve(BCHRPCCLIENT.getTransaction(rows[i].tx_hash));
251 |                     p.then(function(info){
252 | 
253 |                         if(info.confirmations>=BCHCONFIG.minConfirmation)
254 |                             DBSERVICE.updateBCHWithdrawLogById(this.row.id,{tx_status:withdrawLogStatus.MINED,block_number:blockAccount-info.confirmations},function (err,date) {
255 |                                 if(err)
256 |                                     console.log(err);
257 |                                 else{
258 |                                     console.log("Tx id "+this.row.tx_hash+" has been mined successfully!");
259 |                                 }
260 |                             }.bind({row:this.row}))
261 |                     }.bind({row:rows[i]}));
262 | 
263 |                 }
264 |             }
265 |         });
266 |     });
267 | }
268 | 
269 | function getBCHBalanceByUserId(userId,done) {
270 |     DBSERVICE.getBCHDepositeTxsByUserId(userId,function (err,data) {
271 |         if(err)
272 |         {
273 |             return done(err);
274 |         }
275 |         let totalWithdraw =0;
276 |         for(let i=0;i<data.length;i++){
277 |             totalWithdraw+=data[i].value;
278 |         }
279 |         DBSERVICE.getBCHWithdrawTxsByUserId(userId,function (err,data) {
280 |             if(err){
281 |                 return done(err);
282 |             }
283 |             for(let j=0;j<data.length;j++){
284 |                 totalWithdraw-=data[j].bch_value;
285 |             }
286 |             return done(null,totalWithdraw);
287 |         }.bind({totalWithdraw:totalWithdraw}))
288 |     })
289 | }
290 | 
291 | function getUnconfirmedDepositTxByUsername(username,callback) {
292 |     DBSERVICE.getUserByUsername(username,function (err,data) {
293 |         if(err) return callback(err);
294 | 
295 |         let p = Promise.resolve(BCHRPCCLIENT.listTransactions(data[0].username,50,0,true));
296 |         p.then(function (transactions) {
297 |             let unconfirmedTx = [];
298 |             for(let i= 0;i<transactions.length;i++){
299 |                 if(transactions[i].confirmations<=BCHCONFIG.minConfirmation)
300 |                 {
301 |                     let returnTx={
302 |                         txid:transactions[i].txid,
303 |                         amount:transactions[i].amount,
304 |                         confirmations:transactions[i].confirmations,
305 |                         need:20
306 |                     };
307 |                     unconfirmedTx.push(returnTx);
308 |                 }
309 |             }
310 | 
311 |             return callback(null,unconfirmedTx);
312 |         });
313 | 
314 |     })
315 | }
316 | 
317 | function getBCHTransactionByTxHash(txid,done) {
318 |     var p= Promise.resolve(BCHRPCCLIENT.getTransaction(txid));
319 |     p.then(function(data){
320 |         let tx={
321 |             hash:txid,
322 |             confirmations: data.confirmations
323 |         };
324 |         return done(null,tx);
325 |     });
326 | }
327 | 
328 | module.exports = {
329 |     addRecipientAddresses:addRecipientAddresses,
330 |     initRecipientAddresses:initRecipientAddresses,
331 |     checkBlockChainForDepositTx:checkBlockChainForDepositTx,
332 |     updateUnspentTx:updateUnspentTx,
333 |     updateSubmittedWithdrawTxs:updateSubmittedWithdrawTxs,
334 |     withdrawBCH:withdrawBCH,
335 |     getBCHBalanceByUserId:getBCHBalanceByUserId,
336 |     getUnconfirmedDepositTxByUsername:getUnconfirmedDepositTxByUsername,
337 |     getBCHTransactionByTxHash:getBCHTransactionByTxHash
338 | }


--------------------------------------------------------------------------------