epic_explorer/server.ts
2022-12-23 10:21:39 +00:00

392 lines
12 KiB
TypeScript

import "zone.js/dist/zone-node";
import "reflect-metadata";
const fs = require("fs");
const path = require("path");
const template = fs
.readFileSync(path.join(__dirname, ".", "browser", "index.html"))
.toString();
const jsdom = require("jsdom");
const { JSDOM } = jsdom;
const { window } = new JSDOM(template);
global["window"] = window;
Object.defineProperty(window.document.body.style, "transform", {
value: () => {
return {
enumerable: true,
configurable: true
};
}
});
// function noOp () { }
// if (typeof window.URL.createObjectURL === 'undefined') {
// Object.defineProperty(window.URL, 'createObjectURL', { value: noOp})
// }
// global["URL"] = window.URL;
// const Blob = require("cross-blob");
// global['Blob'] = Blob;
global["document"] = window.document;
import { enableProdMode } from "@angular/core";
import { Global } from "./server/global";
// Express Engine
import { ngExpressEngine } from "@nguniversal/express-engine";
// Import module map for lazy loading
import { provideModuleMap } from "@nguniversal/module-map-ngfactory-loader";
import express from "express";
import { Request, Response, NextFunction } from "express";
import bodyParser from "body-parser";
//import { logger } from "./server/utils";
import swaggerJSDoc from "swagger-jsdoc";
import { errorMiddleware, redisMiddleware } from "./server/middlewares";
import {
getRepository,
In,
getConnection,
getConnectionManager,
createConnections
} from "typeorm";
import { resolve } from "path";
import {
BlockchainBlockController,
BlockchainInputController,
BlockchainKernelController,
BlockchainOutputController
} from "./server/controllers";
import {
BlockchainBlock,
BlockchainInput,
BlockchainKernel,
BlockchainOutput
// PeerIp
} from "./server/entities";
import { universalGetLatestBlockDetails } from "./server/socket";
import { dbConfig } from "./server/ormconfig";
import { config } from "dotenv";
import {latestBlockDetails, Details, GetBlocktime, averageblockdifficulty, network_hashrate} from './server/utils';
config({ path: resolve(__dirname, "../.env") });
// const connectionManager = getConnectionManager();
// const connection = connectionManager.create(dbConfig);
import { join } from "path";
var cron = require('node-cron');
// Faster server renders w/ Prod mode (dev mode never needed)
enableProdMode();
// Express server
const app = express();
const PORT = process.env.PORT || 4001;
const DIST_FOLDER = join(process.cwd(), "live");
const controllers = [
new BlockchainBlockController(),
new BlockchainInputController(),
new BlockchainKernelController(),
new BlockchainOutputController()
];
app.use(function(req, res, next) {
// res.header('Access-Control-Allow-Origin', '*');
// res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
// res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Content-Length, X-Requested-With, Accept, Authtoken,cookie_id');
// intercept OPTIONS method
if ('OPTIONS' == req.method) {
return res.status(200).end();
}
else {
next();
}
}
);
app.use(bodyParser.json({ limit: "50mb" }));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(
"/api-docs/**",
express.static(path.join(__dirname, "./server/swagger"))
);
app.get("/swagger.json", function(req, res) {
res.setHeader("Content-Type", "application/json");
res.send(
swaggerJSDoc({
swaggerDefinition: require("./swagger/swagger.json"),
apis: ["**/*.ts"]
})
);
});
controllers.forEach(controller => {
app.use("/epic_explorer/v1", controller.router);
});
// Example Express Rest API endpoints
import request from 'request-promise';
//import { PeerIp } from './server/entities/PeerIp';
app.get("/api", redisMiddleware('60'), async (req, res) => {
try {
let option = req.query.q;
let blockDetails = await latestBlockDetails();
if(option)
{
let result; //500
if(option == "circulating")
// result= Number(blockDetails.coin_existence - blockDetails.totalFoundationReward);
result = Number(blockDetails.coin_existence);
else if(option == "reward")
result= Number(blockDetails.currentReward);
else if(option == "getblockcount")
result= Number(blockDetails.block_height);
else if(option == "getdifficulty-randomx")
result = Number(blockDetails.TotalDifficultyRandomx);
else if(option == "getdifficulty-cuckoo")
result = Number(blockDetails.TotalCuckoo);
else if(option == "getdifficulty-progpow")
result = Number(blockDetails.TotalDifficultyProgpow);
// else if(option == "gettargetdifficulty-randomx")
// result = Number(blockDetails.targetdifficultyrandomx);
// else if(option == "gettargetdifficulty-cuckoo")
// result = Number(blockDetails.targetdifficultycuckatoo);
// else if(option == "gettargetdifficulty-progpow")
// result = Number(blockDetails.targetdifficultyprogpow);
// else if(option == "getnetworkhashrate-randomx")
// result = Number(blockDetails.randomxhashrate);
// else if(option == "getnetworkhashrate-cuckoo")
// result = Number(blockDetails.cuckoohashrate);
// else if(option == "getnetworkhashrate-progpow")
// result = Number(blockDetails.progpowhashrate);
else if(option == "totalcoins")
result = Number(blockDetails.coin_existence);
else if(option == "maxcoins")
result = Number(21000000);
else if(option == "average-blocktime")
{
let data = await averageblockdifficulty();
result = Number(data);
}
else if(option == "network-hashrate-cuckoo")
{
let data = await network_hashrate(blockDetails.block_height,31,blockDetails.targetdifficultycuckatoo,"Cuckoo");
result = data;
}
else if(option == "network-hashrate-progpow")
{
let data = await network_hashrate(blockDetails.block_height,16,blockDetails.targetdifficultyprogpow,"ProgPow");
result = data;
}
else if(option == "network-hashrate-randomx")
{
let data = await network_hashrate(blockDetails.block_height,16,blockDetails.targetdifficultyrandomx,"RandomX");
result = data;
}
else if(option == "getblockhash")
{
let height = req.query.height;
if(height) {
let heighthash = await Details(height);
if(heighthash[0].hash)
result = heighthash[0].hash;
else
result = 'Invalid height';
} else if(height <0) {
result = '"height" parameter missing or invalid';
} else {
result = '"height" parameter missing or invalid';
}
}
else if(option == "getblockheight")
{
let hash = req.query.hash;
if(hash) {
let heighthash = await Details(hash);
if(heighthash[0].height)
result = heighthash[0].height;
else
result = 'Invalid hash';
} else {
result = '"hash" parameter missing or invalid';
}
}
else if(option == "getblocktime"){
let height = req.query.height;
if(height) {
let blockTime = await GetBlocktime(height);
if(blockTime[0].alter)
result = blockTime[0].alter;
else
result = 'Invalid height';
} else if(height < 0) {
result = '"height" parameter missing or invalid';
} else {
result = '"height" parameter missing or invalid';
}
}
else if(option == "info")
{
result = {
"Name": "Epic Cash",
"Symbol": "EPIC",
"TotalSupply": 21000000,
"CurrentSupply": blockDetails.coin_existence,
"MinerCurrentBlockReward": blockDetails.userReward,
"Algorithms": "Cuckoo, RandomX, ProgPow",
"Target_Difficulty": {
"Cuckoo": blockDetails.targetdifficultycuckaroo + blockDetails.targetdifficultycuckatoo,
"RandomX": blockDetails.targetdifficultyrandomx,
"ProgPow": blockDetails.targetdifficultyprogpow
},
"Total_Difficulty": {
"Cuckoo": blockDetails.TotalCuckoo,
"RandomX": blockDetails.TotalDifficultyRandomx,
"ProgPow": blockDetails.TotalDifficultyProgpow
},
"BlockHeight": blockDetails.block_height,
"Blockchain": "MimbleWimble",
"Homepage": "https://epic.tech",
"Explorer": "https://explorer.epic.tech",
"API": "https://explorer.epic.tech/api",
"Logo": "https://explorer.epic.tech/assets/img/logo.png",
"ICO": "NO",
"Premine": "NO",
"Mainnet": "YES",
"Genesis": "09-03-2019, 02:09:00 UTC",
"BlockInterval": 60,
"GIT": "https://gitlab.com/epiccash",
"Whitepaper":"https://epic.tech/whitepaper",
"Colors": { "off-white": "#f3f4f2", "off-black": "#222223", "gold" :"#bf9b30" }
};
}
else
result= "Invalid Option";
var type = typeof result;
if (type == "object") {
res.status(200).json({...result});
}
else {
res.status(200).json(result);
}
}
else
{
//let result= 5;
res.redirect('/api-index');
}
}
catch(err){
res.status(500).send("Internal Server Error");
}
});
app.get("/epic_explorer/v1/**", (req, res) => {
res.send({ msg: "Api works." });
});
app.use(errorMiddleware);
// * NOTE :: leave this as require() since this file is built Dynamically from webpack
const { AppServerModuleNgFactory, LAZY_MODULE_MAP } = require("./server/main");
// Our Universal express-engine (found @ https://github.com/angular/universal/tree/master/modules/express-engine)
app.engine(
"html",
ngExpressEngine({
bootstrap: AppServerModuleNgFactory,
providers: [provideModuleMap(LAZY_MODULE_MAP)]
})
);
app.set("views", join(DIST_FOLDER, "browser"));
app.set("view engine", "html");
// Server static files from /browser
app.get(
"*.*",
express.static(join(DIST_FOLDER, "browser"), {
maxAge: "1y"
})
);
// All regular routes use the Universal engine
app.get("*", (req, res) => {
res.sendFile(join(DIST_FOLDER, "browser") + "/index.html", { req });
});
// Start up the Node server
console.log(__dirname);
// connection
// .connect()
// .then(() => {
createConnections([ {
name: 'Floonet',
type: 'postgres',
host: process.env.FLOONET_DB_HOST,
port: Number(process.env.FLOONET_DB_PORT),
username: process.env.FLOONET_DB_USERNAME,
password: process.env.FLOONET_DB_PASSWORD,
database: process.env.FLOONET_DB_DATABASE,
synchronize: false,
logging: false,
entities: [BlockchainBlock,
BlockchainInput,
BlockchainKernel,
BlockchainOutput],
}, {
name: 'Testnet',
type: 'postgres',
host: process.env.TESTNET_DB_HOST,
port: Number(process.env.TESTNET_DB_PORT),
username: process.env.TESTNET_DB_USERNAME,
password: process.env.TESTNET_DB_PASSWORD,
database: process.env.TESTNET_DB_DATABASE,
synchronize: false,
logging: false,
entities: [BlockchainBlock,
BlockchainInput,
BlockchainKernel,
BlockchainOutput],
}]).then(async () => {
const server = app.listen(PORT, () => {
console.log(`Node Express server listening on http://localhost:${PORT}`);
});
// cron.schedule('*/30 * * * * *', () => {
// universalGetLatestBlockDetails('Testnet');
// });
var interval;
const io = require("socket.io").listen(server);
io.sockets.on("connection", socket => {
// if (interval) {
// clearInterval(interval);
// }
//console.log(socket.handshake.query.network);
//var network = "Testnet";
let key = process.env.REDIS_KEY + socket.handshake.query.network + 'Latest_Block_details'
interval = setInterval(function() {
Global.client.get(key, function(err, reply){
// socket.emit("latestblockdetail", JSON.parse(reply) );
});
},10000);
//socket.on("disconnect", () => console.log("Client disconnected"));
});
})
.catch(error => {
console.log("connection failed..", error);
});