tera/src/core/node.ts

/*
 * @project: TERA
 * @version: Development (beta)
 * @license: MIT (not for evil)
 * @copyright: Yuriy Ivanov (Vtools) 2017-2019 [progr76@gmail.com]
 * Web: https://terafoundation.org
 * Twitter: https://twitter.com/terafoundation
 * Telegram:  https://t.me/terafoundation
*/

"use strict";
import "./library"
import * as net from "net"
import { secp256k1, RBTree } from '../core/library'
import { TeraSocket, SocketSendInfo } from "../interfaces/server";
var ConnectIDCount = 1;

export default class CNode {
    id: number;
    addrStr: string
    ip: string
    port: number
    StartFindList: number
    WhiteConnect: number
    GrayConnect: number
    POW: number
    FirstTime: number
    FirstTimeStr: string
    LastTime: number
    LastTimeError: number
    LastTimeTransfer: number
    FromIP: any
    FromPort: any
    Active: boolean
    Hot: boolean
    CanHot: boolean
    CountChildConnect: number
    BlockProcessCount: number
    VersionOK: boolean
    VersionNum: number
    Delete: number
    DeltaBan: number
    Name: string
    Info: string
    PrevInfo: string
    StartTimeHot: number
    NextHotDelta: number
    LastTimeGetNode: number
    DeltaGlobTime: number
    CountDeltaTime: number
    DeltaTime: number
    SumDeltaTime: number
    TransferCount: number
    StopGetBlock: number
    LevelCount: number
    LevelEnum: number
    TimeMap: {}
    bInit: number
    INFO: {
        BlockNumDB?: number;
        WasPing?: boolean;
        LoadHistoryMode?: boolean;
        portweb?: number
    }
    DoubleConnectCount: number
    StartTimeConnect: number
    NextConnectDelta: number
    StartTimeGetNodes: number
    NextGetNodesDelta: number
    PingStart: number
    NextPing: number
    SendBlockArr: any[]
    LoadBlockArr: any[]
    SendBlockCount: number
    LoadBlockCount: number
    SendBlockCountAll: number
    LoadBlockCountAll: number
    WantHardTrafficArr: any[]
    WantHardTraffic: number
    CanHardTraffic: number
    BufWriteLength: number
    BufWrite: Buffer | Uint8Array
    SendPacket: RBTree<SocketSendInfo>
    ConnectCount: number
    TrafficArr: any[]
    SendTrafficCurrent: number
    SendTrafficLimit: number
    ErrCount: number
    ErrCountAll: number
    SendPacketNum: number
    Socket: TeraSocket
    Socket2: TeraSocket
    ReconnectFromServer: number
    SecretForReconnect: any[] | Buffer
    Self: boolean
    addrStrTemp: any
    DoubleConnection: boolean
    PubKey: Buffer
    addrArr: any[]
    SocketStart: number
    WaitConnectFromServer: number
    WaitConnectIP: string
    Prioritet: any
    WasAddToReconnect: number
    WasAddToConnect: number
    Level: number
    SendRestGetHeader: number
    TransferBlockNum: number;
    CurBlockNum: number;
    NoSendTx: any;
    VERSIONMAX: any;
    LoadHistoryMode: boolean;
    portweb: number;
    PingNumber: number;
    DeltaTimeM: number;
    Times: { Arr: number[] };
    AvgDelta: number;
    IsAddrList: boolean;
    КодДляРазработчикаХекс: any;
    ip_arrival: string;
    port_arrival: number;
    TransferSize: number;
    TransferBlockNumFix: number;
    constructor(addrStr: string, ip: string, port: number) {
        this.addrStr = addrStr
        this.ip = ip.trim()
        this.port = port
        this.StartFindList = 0
        this.WhiteConnect = 0
        this.GrayConnect = 0
        this.POW = 0
        this.FirstTime = 0
        this.FirstTimeStr = ""
        this.LastTime = 0
        this.LastTimeError = 0
        this.LastTimeTransfer = 0
        this.FromIP = undefined
        this.FromPort = undefined
        this.Active = false
        this.Hot = false
        this.CanHot = false
        this.CountChildConnect = 0
        this.BlockProcessCount = 0
        this.VersionOK = false
        this.VersionNum = 0
        this.Delete = 0
        this.DeltaBan = 300
        this.Name = ""
        this.Info = ""
        this.PrevInfo = ""
        this.StartTimeHot = 0
        this.NextHotDelta = 1000
        this.ResetNode()
    }
    ResetNode() {
        this.LastTimeGetNode = 0
        this.DeltaGlobTime = 0
        this.CountDeltaTime = 0
        this.DeltaTime = 1000
        this.SumDeltaTime = 0
        this.TransferCount = 0
        this.StopGetBlock = 0
        this.LevelCount = 0
        this.LevelEnum = 100
        this.TimeMap = {}
        this.bInit = 1
        this.INFO = {}
        this.DoubleConnectCount = 0
        this.StartTimeConnect = 0
        this.NextConnectDelta = 1000
        this.StartTimeGetNodes = 0
        this.NextGetNodesDelta = 1000
        this.PingStart = 0
        this.NextPing = global.MIN_PERIOD_PING
        this.SendBlockArr = []
        this.LoadBlockArr = []
        this.SendBlockCount = 0
        this.LoadBlockCount = 0
        this.SendBlockCountAll = 0
        this.LoadBlockCountAll = 0
        this.WantHardTrafficArr = []
        this.WantHardTraffic = 0
        this.CanHardTraffic = 0
        this.BufWriteLength = 0
        this.BufWrite = Buffer.alloc(0)
        this.SendPacket = new RBTree(function(a, b) {
            return b.PacketNum - a.PacketNum;
        } as any)
        this.ConnectCount = 0
        this.TrafficArr = []
        this.SendTrafficCurrent = 0
        this.SendTrafficLimit = 0
        this.ErrCount = 0
        this.ErrCountAll = 0
        var Prioritet = this.BlockProcessCount;
        global.SERVER.SetNodePrioritet(this, Prioritet)
        this.SendPacketNum = 0
    }
    ConnectStatus() {
        if (this.Socket)
            return GetSocketStatus(this.Socket);
        else
            return 0;
    }
    CreateConnect() {
        delete global.SERVER.BAN_IP[this.ip]
        let NODE = this;
        if (NODE.ConnectStatus()) {
            if (NODE.ConnectStatus() === 100)
                global.SERVER.AddNodeToActive(NODE)
            return;
        }
        global.AddNodeInfo(NODE, "===CreateConnect===")
        global.CloseSocket(NODE.Socket, "CreateConnect")
        NODE.SocketStart = Date.now()
        NODE.Socket = net.createConnection(NODE.port, NODE.ip, function() {
            if (NODE.Socket) {
                global.socketInit(NODE.Socket, "s")
                global.AddNodeInfo(NODE, "OK connected *" + NODE.Socket.ConnectID)
                NODE.Socket.ConnectToServer = true
                SetSocketStatus(NODE.Socket, 2)
            }
        }) as TeraSocket
        SetSocketStatus(NODE.Socket, 1)
        NODE.Socket.Node = NODE
        NODE.Socket.ConnectID = "~C" + ConnectIDCount
        ConnectIDCount++
        this.SetEventsProcessing(NODE.Socket, 0)
    }
    CreateReconnection() {
        let NODE = this;
        global.AddNodeInfo(NODE, "===CreateReconnection===")
        global.CloseSocket(NODE.Socket2, "CreateReconnection")
        NODE.SocketStart = Date.now()
        NODE.Socket2 = net.createConnection(NODE.port, NODE.ip, function() {
            if (NODE.Socket2) {
                global.socketInit(NODE.Socket2, "s")
                global.AddNodeInfo(NODE, "OK Reconnected *" + NODE.Socket2.ConnectID)
                NODE.Socket2.ConnectToServer = true
                SetSocketStatus(NODE.Socket2, 2)
            }
        }) as TeraSocket
        SetSocketStatus(NODE.Socket2, 1)
        NODE.Socket2.Node = NODE
        NODE.Socket2.ConnectID = "~R" + ConnectIDCount
        ConnectIDCount++
        this.SetEventsProcessing(NODE.Socket2, 1)
    }
    SwapSockets() {
        if (!this.Socket2)
            return;
        var SocketOld = this.Socket;
        this.Socket = this.Socket2
        this.Socket2 = undefined
        this.Socket.Node = this
        SetSocketStatus(this.Socket, 100)
        this.Socket.Buf = SocketOld.Buf
        global.SERVER.LoadBufSocketList.remove(SocketOld)
        global.SERVER.LoadBufSocketList.insert(this.Socket)
        SocketOld.Buf = undefined
        SocketOld.WasClose = 1
        SocketOld.Node = undefined
        this.ErrCount = 0
    }
    SetEventsProcessing(Socket, Reconnection) {
        let SOCKET = Socket;
        let NODE = this;
        let RECONNECTION = Reconnection;
        SOCKET.on('data', function(data) {
            if (Socket.WasClose)
                return;
            if (GetSocketStatus(SOCKET) === 2) {
                SetSocketStatus(SOCKET, 3)
                var Buf = global.SERVER.GetDataFromBuf(data);
                if (Buf) {
                    var Res = NODE.SendPOWFromClientToServer(SOCKET, Buf.Data);
                    if (Res) {
                        return;
                    }
                }
                global.CloseSocket(SOCKET, Buf ? "Method=" + Buf.Method : "=CLIENT ON DATA=")
            }
            else
                if (GetSocketStatus(SOCKET) === 3) {
                    var Buf = global.SERVER.GetDataFromBuf(data);
                    if (Buf) {
                        var Str = Buf.Data;
                        if (Str && Str.substr(0, 24) === "WAIT_CONNECT_FROM_SERVER") {
                            global.AddNodeInfo(NODE, "2. CLIENT OK POW")
                            global.CloseSocket(SOCKET, "WAIT_CONNECT_FROM_SERVER")
                            NODE.WaitConnectFromServer = 1
                            NODE.WaitConnectIP = NODE.ip
                            try {
                                NODE.SecretForReconnect = global.GetArrFromHex(Str.substr(25))
                            }
                            catch (e) {
                                NODE.SecretForReconnect = []
                                global.ToLog(e)
                            }
                        }
                        else
                            if (Str === "OK") {
                                NODE.NextConnectDelta = 1000
                                SetSocketStatus(SOCKET, 100)
                                global.AddNodeInfo(NODE, "4. CLIENT OK CONNECT")
                                if (RECONNECTION) {
                                    if (NODE.Socket)
                                        SetSocketStatus(NODE.Socket, 200)
                                }
                                else {
                                    if (!NODE.Active)
                                        global.SERVER.AddNodeToActive(NODE)
                                }
                                return;
                            }
                            else
                                if (Str === "SELF") {
                                    NODE.Self = true
                                }
                                else
                                    if (Str === "DOUBLE") {
                                    }
                                    else {
                                        global.AddNodeInfo(NODE, "ERROR:" + Str)
                                    }
                    }
                    global.CloseSocket(SOCKET, Buf ? "Method=" + Buf.Method + ":" + Str : "=CLIENT ON DATA=")
                }
                else {
                    global.socketRead(Socket, data)
                    global.SERVER.OnGetFromTCP(NODE, Socket, data)
                }
        })
        SOCKET.on('end', function() {
            if (GetSocketStatus(SOCKET))
                global.AddNodeInfo(NODE, "Get socket end *" + SOCKET.ConnectID + " Stat: " + SocketStatistic(SOCKET))
            if (GetSocketStatus(SOCKET) === 200) {
                NODE.SwapSockets()
                SOCKET.WasClose = 1
            }
        })
        SOCKET.on('close', function(err) {
            if (SOCKET.ConnectID && GetSocketStatus(SOCKET))
                global.AddNodeInfo(NODE, "Get socket close *" + SOCKET.ConnectID + " Stat: " + SocketStatistic(SOCKET))
            if (!SOCKET.WasClose) {
                if (GetSocketStatus(SOCKET) >= 2) {
                    global.CloseSocket(SOCKET, "GET CLOSE")
                }
            }
            SetSocketStatus(SOCKET, 0)
        })
        SOCKET.on('error', function(err) {
            if (GetSocketStatus(SOCKET) >= 2) {
                global.SERVER.AddCheckErrCount(NODE, 1, "ERR##1 : socket")
                global.ADD_TO_STAT("ERRORS")
            }
        })
    }
    SendPOWFromClientToServer(Socket, data) {
        var Node = this;
        if (Node.ReconnectFromServer) {
            Node.ReconnectFromServer = 0
            var Info = this.GetPOWClientData(0);
            Info.Reconnect = 1
            Info.SecretForReconnect = Node.SecretForReconnect
            var BufWrite = global.BufLib.GetBufferFromObject(Info, global.FORMAT_POW_TO_SERVER, 1200, {});
            var BufAll = global.SERVER.GetBufFromData("POW_CONNECT7", BufWrite, 1);
            Socket.write(BufAll)
            return 1;
        }
        try {
            var Buf = global.BufLib.GetObjectFromBuffer(data, global.FORMAT_POW_TO_CLIENT, {});
        } catch (e) {
            global.SERVER.SendCloseSocket(Socket, "FORMAT_POW_TO_CLIENT")
            return 0;
        }
        if (global.CompareArr(Buf.addrArr, global.SERVER.addrArr) === 0) {
            Node.Self = true
            global.AddNodeInfo(Node, "END: SELF")
            global.SERVER.SendCloseSocket(Socket, "SELF")
            return;
        }
        var addrStr = global.GetHexFromAddres(Buf.addrArr);
        if (!Node.StartFindList && addrStr !== Node.addrStr) {
            global.AddNodeInfo(Node, "END: CHANGED ADDR: " + Node.addrStr.substr(0, 16) + "->" + addrStr.substr(0, 16))
            global.SERVER.SendCloseSocket(Socket, "ADDRESS_HAS_BEEN_CHANGED")
            return;
        }
        if (Node.addrStrTemp) {
            global.AddNodeInfo(Node, "Set Addr = " + addrStr)
            Node.addrStr = addrStr
            global.SERVER.CheckNodeMap(Node)
        }
        var Result = false;
        if (Buf.PubKeyType === 2 || Buf.PubKeyType === 3) {
            Result = secp256k1.verify(Buffer.from(global.shaarr(addrStr)), Buffer.from(Buf.Sign), Buffer.from([Buf.PubKeyType].concat(Buf.addrArr)))
            if (!Result) {
                Result = secp256k1.verify(Buffer.from(global.sha3(addrStr)), Buffer.from(Buf.Sign), Buffer.from([Buf.PubKeyType].concat(Buf.addrArr)))
            }
        }
        if (!Result) {
            global.ToLog("END: ERROR_SIGN_SERVER ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
            global.AddNodeInfo(Node, "END: ERROR_SIGN_SERVER ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
            global.SERVER.SendCloseSocket(Socket, "ERROR_SIGN_SERVER")
            return;
        }
        if (Buf.MIN_POWER_POW_HANDSHAKE > 1 + global.MIN_POWER_POW_HANDSHAKE) {
            global.ToLog("END: BIG_MIN_POWER_POW_HANDSHAKE ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
            return 0;
        }
        var TestNode = global.SERVER.NodesMap[addrStr];
        if (TestNode && TestNode !== Node) {
            if (GetSocketStatus(TestNode.Socket)) {
                global.AddNodeInfo(Node, "DoubleConnection find")
                Node.DoubleConnection = true
                return 0;
            }
            else {
                global.AddNodeInfo(Node, "DoubleConnection find")
                TestNode.DoubleConnection = true
            }
        }
        Node.PubKey = Buffer.from([Buf.PubKeyType].concat(Buf.addrArr))
        Node.addrArr = Buf.addrArr
        Node.addrStr = addrStr
        if (global.CompareArr(global.SERVER.addrArr, Node.addrArr) === 0) {
            Node.Self = true
            return 0;
        }
        var Hash = global.shaarr2(Buf.addrArr, Buf.HashRND);
        var nonce = global.CreateNoncePOWExternMinPower(Hash, 0, Buf.MIN_POWER_POW_HANDSHAKE);
        var Info;
        if (global.WALLET.WalletOpen && global.IsDeveloperAccount(global.WALLET.PubKeyArr)) {
            Info = this.GetPOWClientData(0)
            Info.Reconnect = 255
            Info.Sign = secp256k1.sign(global.SHA3BUF(Hash), global.WALLET.KeyPair.getPrivateKey('')).signature
            Result = global.CheckDevelopSign(Hash, Info.Sign)
            if (!Result) {
                throw "ERROR DEVELOPSIGN!";
            }
        }
        else {
            Info = this.GetPOWClientData(nonce)
            Info.PubKeyType = global.SERVER.PubKeyType
            Info.Sign = secp256k1.sign(Buffer.from(Hash), global.SERVER.KeyPair.getPrivateKey('')).signature
        }
        var BufWrite = global.BufLib.GetBufferFromObject(Info, global.FORMAT_POW_TO_SERVER, 1200, {});
        var BufAll = global.SERVER.GetBufFromData("POW_CONNECT6", BufWrite, 1);
        Socket.write(BufAll)
        return 1;
    }
    GetPOWClientData(nonce) {
        var Node = this;
        var Info: any = {};
        Info.DEF_NETWORK = global.GetNetworkName()
        Info.DEF_VERSION = global.DEF_VERSION
        Info.DEF_CLIENT = global.DEF_CLIENT
        Info.addrArr = global.SERVER.addrArr
        Info.ToIP = Node.ip
        Info.ToPort = Node.port
        Info.FromIP = global.SERVER.ip
        Info.FromPort = global.SERVER.port
        Info.nonce = nonce
        Info.Reconnect = 0
        Info.SendBytes = 0
        Info.SecretForReconnect = []
        Info.Reserv = []
        if (global.GrayConnect())
            Info.GrayConnect = 1
        return Info;
    }
    write(BufWrite) {
        if (!this.Socket)
            return;
        global.socketWrite(this.Socket, BufWrite)
        try {
            this.Socket.write(BufWrite)
        }
        catch (e) {
            global.ToError(e)
            this.Socket.WasClose = 1
            this.Socket.SocketStatus = 0
            this.Socket.Node = undefined
        }
    }
};
global.socketInit = function(Socket, Str) {
    if (!Socket)
        return;
    Socket.GetBytes = 0;
    Socket.SendBytes = 0;
    Socket.ConnectID = "" + ConnectIDCount + Str;
    ConnectIDCount++;
};
global.socketRead = function(Socket, Buf) {
    Socket.GetBytes += Buf.length;
};
global.socketWrite = function(Socket, Buf) {
    Socket.SendBytes += Buf.length;
};
global.CloseSocket = function(Socket, StrError?, bHide?) {
    if (!Socket || Socket.WasClose) {
        if (Socket)
            Socket.SocketStatus = 0;
        return;
    }
    var Node = Socket.Node;
    if (Socket.Node && Socket.Node.Socket2 === Socket && Socket.Node.Socket && Socket.Node.Socket.SocketStatus === 200)
        SetSocketStatus(Socket.Node.Socket, 100);
    var StrNode = NodeInfo(Socket.Node);
    Socket.WasClose = 1;
    Socket.SocketStatus = 0;
    Socket.Node = undefined;
    Socket.end();
    if (!bHide)
        global.AddNodeInfo(Node, "CLOSE " + StrNode + "  *" + Socket.ConnectID + " - " + StrError);
};

function SetSocketStatus(Socket, Status) {
    if (Socket && Socket.SocketStatus !== Status) {
        if (Status === 100 && (Socket.SocketStatus !== 3 && Socket.SocketStatus !== 200)) {
            global.ToLogTrace("===================ERROR=================== " + Status);
            return;
        }
        if (Status === 100 && Socket.Node)
            Socket.Node.LastTime = global.GetCurrentTime() - 0;
        Socket.SocketStatus = Status;
        Socket.TimeStatus = Date.now();
    }
};

function GetSocketStatus(Socket) {
    if (Socket && Socket.SocketStatus) {
        if (Socket.SocketStatus !== 100) {
            var Delta = Date.now() - Socket.TimeStatus;
            if (Delta > global.MAX_WAIT_PERIOD_FOR_STATUS) {
                global.CloseSocket(Socket, "MAX_WAIT_PERIOD_FOR_STATUS = " + Socket.SocketStatus + " time = " + Delta);
            }
        }
        return Socket.SocketStatus;
    }
    else {
        return 0;
    }
};

function SocketInfo(Socket) {
    if (Socket)
        return "*" + Socket.ConnectID;
    else
        return "";
};

function SocketStatistic(Socket) {
    if (!Socket)
        return "";
    var Str = "";
    if (!Socket.SendBytes)
        Socket.SendBytes = 0;
    if (!Socket.GetBytes)
        Socket.GetBytes = 0;
    if (Socket.SendBytes)
        Str += " Send=" + Socket.SendBytes;
    if (Socket.GetBytes)
        Str += " Get=" + Socket.GetBytes;
    if (GetSocketStatus(Socket))
        Str += " SocketStatus=" + GetSocketStatus(Socket);
    if (Str === "")
        Str = "0";
    return Str;
};

function NodeInfo(Node) {
    if (Node)
        return "" + Node.ip + ":" + Node.port + " " + SocketInfo(Node.Socket);
    else
        return "";
};

function NodeName(Node) {
    if (!Node)
        return "";
    if (Node.Name)
        return Node.Name;
    if (global.LOCAL_RUN)
        return "" + Node.port;
    else {
        return "" + Node.ip + ":" + Node.addrStr.substr(0, 6);
    }
};

function FindNodeByAddr(Addr, bConnect) {
    var Node = global.SERVER.NodesMap[Addr.trim()];
    if (Node && Node.ConnectStatus() === 100)
        return Node;
    if (Node && bConnect) {
        Node.NextConnectDelta = 1000;
        global.SERVER.StartConnectTry(Node);
        return false;
    }
    return undefined;
};

function AddNodeInfo(Node, Str, bSet) {
    if (!global.STAT_MODE)
        return;
    if (!Node)
        return;
    if (!Node.Info)
        Node.Info = "";
    if (bSet) {
        Node.Info = "";
    }
    else {
        if (Node.Socket && Node.Socket.Info) {
            Node.Info += Node.Socket.Info + "\n";
            Node.Socket.Info = "";
        }
    }
    if (Node.Info.length > 1000) {
        Node.PrevInfo = Node.Info;
        Node.Info = "";
    }
    {
        var timesend = global.GetStrOnlyTimeUTC();
        Str = timesend + " " + Str;
        Node.Info += Str + "\n";
    }
};
global.SocketStatistic = SocketStatistic;
global.GetSocketStatus = GetSocketStatus;
global.SetSocketStatus = SetSocketStatus;
global.NodeInfo = NodeInfo;
global.NodeName = NodeName;
global.SocketInfo = SocketInfo;
global.FindNodeByAddr = FindNodeByAddr;
global.AddNodeInfo = AddNodeInfo;