public DBFileInfo RequestHightestDBInfo()
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.DBfile;
sendMod.Value = DBRequestType.RequestDBInfo;
List <DBFileInfo> lstDBInfo = new List <DBFileInfo>();
foreach (var item in this.dicAddressesPool)
{
XXPSocketsModel RetMod = this.XXPSendMessage(item.Key, sendMod);
if (!string.IsNullOrEmpty(RetMod.Value))
{
DBFileInfo dbInfo = JsonHelper.Deserialize <DBFileInfo>(RetMod.Value);
dbInfo.IP = RetMod.IpAddress;
lstDBInfo.Add(dbInfo);
}
}
var ss = lstDBInfo.Max(x => x.LastBlockHeight);
DBFileInfo hightestDBInfo = lstDBInfo.FirstOrDefault(x => x.LastBlockHeight == ss);
LogHelper.WriteInfoLog("HightestDBInfo: " + JsonHelper.Serializer <DBFileInfo>(hightestDBInfo));
return(hightestDBInfo);
}
public string ReplyPriTx(string ip, Transaction Tx)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.SignedPriTx;
if (Tx != null)
{
sendMod.Value = JsonHelper.Serializer <Transaction>(Tx);
}
else
{
sendMod.Value = Decision.Reject;
}
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod);
if (RcvMod.Type == XXPCoinMsgType.Exception)
{
return("Exception");
}
else
{
LogHelper.WriteInfoLog("ReplyPriTx ret: " + RcvMod.Value);
return(RcvMod.Value);
}
}
public string SendPriTx(string ip, Transaction Tx)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.Pritransaction;
sendMod.Value = JsonHelper.Serializer <Transaction>(Tx);
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod);
if (RcvMod.Type == XXPCoinMsgType.Exception)
{
return("Exception");
}
else
{
LogHelper.WriteInfoLog("SendPriTx ret: " + RcvMod.Value);
// 兼容0.5及以下版本，
if (string.IsNullOrEmpty(RcvMod.Value) && string.IsNullOrEmpty(RcvMod.Value))
{
RcvMod.Type = XXPCoinMsgType.Unkonw;
RcvMod.Value = XXPCoinMsgType.Unkonw;
}
return(RcvMod.Value);
}
}
public void SendNewAddress2Others(List <string> lstNewAddress)
{
LogHelper.WriteMethodLog(true);
if (lstNewAddress.Count == 0)
{
LogHelper.WriteMethodLog(false);
return;
}
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.NewAddresses;
foreach (var item in lstNewAddress)
{
sendMod.Value += item + "|";
}
Dictionary <string, int> dicAddPool = new Dictionary <string, int>();
dicAddPool = this.dicAddressesPool;
foreach (var item in dicAddPool)
{
this.XXPSendMessage(item.Key, sendMod);
}
LogHelper.WriteMethodLog(false);
}
public ResponseBlock RequestNewBlockInfo(Block lastBlock)
{
LogHelper.WriteMethodLog(true);
RequestBlock ReqBkInfo = new RequestBlock();
ReqBkInfo.RequestType = BlockRequestType.RequestBlockInfo;
ReqBkInfo.LastBlockHash = lastBlock.Hash;
ReqBkInfo.LastBlockHeight = lastBlock.Header.Height;
string strValue = JsonHelper.Serializer <LastBlockInfo>(ReqBkInfo);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.SyncBlocks;
sendMod.Value = strValue;
ResponseBlock ResponseBkInfo = new ResponseBlock();
List <ResponseBlock> lstResponse = new List <ResponseBlock>();
Dictionary <string, int> dicAddPool = new Dictionary <string, int>();
dicAddPool = this.dicAddressesPool;
foreach (var item in dicAddPool)
{
XXPSocketsModel RetMod = this.SocketsHelp.XXPSendMessage(item.Key, sendMod, AppSettings.XXPCommport);
if (RetMod.Type == XXPCoinMsgType.Exception)
{
int lostCount = item.Value;
//this.dicAddressesPool[item.Key] = lostCount++;
return(ResponseBkInfo);
}
else if (!string.IsNullOrEmpty(RetMod.Value))
{
ResponseBlock bkInfo = JsonHelper.Deserialize <ResponseBlock>(RetMod.Value);
bkInfo.IP = RetMod.IpAddress;
lstResponse.Add(bkInfo);
}
}
int OrphanCount = lstResponse.Count(x => x.BlockResult == BlockResultType.OrphanBlock);
if (OrphanCount > lstResponse.Count / 2)
{
ResponseBkInfo.BlockResult = BlockResultType.OrphanBlock;
}
else
{
int iHighest = lstResponse.Max(x => x.LastBlockHeight);
ResponseBkInfo = lstResponse.FirstOrDefault(x => x.LastBlockHeight == iHighest);
}
LogHelper.WriteInfoLog("RequestNewBlockInfo ret: " + ResponseBkInfo.BlockResult);
return(ResponseBkInfo);
}
public string SendNewtransactions(string ip, Transaction Tx)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.Newtransactions;
sendMod.Value = JsonHelper.Serializer <Transaction>(Tx);
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod);
LogHelper.WriteInfoLog("SendNewtransactions ret: " + RcvMod.Value);
return(RcvMod.Value);
}
public string SendNewBlock(string ip, Block block)
{
LogHelper.WriteMethodInfoLog(ip, block.Hash);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.NewBlock;
sendMod.Value = JsonHelper.Serializer <Block>(block);
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod, 20000);
LogHelper.WriteInfoLog(string.Format("SendNewBlock to {0} return: {1}", ip, RcvMod.Value));
return(RcvMod.Value);
}
public string RequestStartTransDB(string IP)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.DBfile;
sendMod.Value = DBRequestType.StratTransfer;
XXPSocketsModel RetMod = this.XXPSendMessage(IP, sendMod);
LogHelper.WriteInfoLog("RequestStartTransDB ret: " + RetMod.Value);
return(RetMod.Value);
}
private XXPSocketsModel XXPSocketsExecuteCallBack(XXPSocketsModel mod)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel refMod = new XXPSocketsModel();
refMod.IpAddress = OSHelper.GetLocalIP();
refMod.Type = string.Empty;
switch (mod.Type)
{
case XXPCoinMsgType.DBfile:
refMod.Type = XXPCoinMsgType.DBfile;
refMod.Value = HandlleDBfileEvent(mod);
break;
case XXPCoinMsgType.Handshake:
refMod.Type = XXPCoinMsgType.Handshake;
refMod.Value = this.HandlleHandshakeEvent(mod);
break;
case XXPCoinMsgType.NewAddresses:
refMod.Type = XXPCoinMsgType.NewAddresses;
refMod.Value = handleNewAddress(mod);
break;
case XXPCoinMsgType.SyncBlocks:
refMod.Type = XXPCoinMsgType.SyncBlocks;
refMod.Value = handleSyncBlocks(mod);
break;
case XXPCoinMsgType.Newtransactions:
refMod.Type = XXPCoinMsgType.Newtransactions;
refMod.Value = handleNewtransactions(mod);
break;
case XXPCoinMsgType.NewBlock:
refMod.Type = XXPCoinMsgType.NewBlock;
refMod.Value = handleNewBlock(mod);
break;
case XXPCoinMsgType.Message:
break;
default:
break;
}
LogHelper.WriteMethodLog(false);
return(refMod);
}
private string handlePriTx(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
Transaction tx = new Transaction();
if (!string.IsNullOrEmpty(socketMod.Value))
{
tx = JsonHelper.Deserialize <Transaction>(socketMod.Value);
}
string sRet = this.PriTxCallBack(tx, socketMod.IpAddress);
LogHelper.WriteInfoLog("handlePriTx ret: " + sRet);
return(sRet);
}
public void NotifyOffline()
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.Handshake;
sendMod.Value = ConstHelper.BC_NotifyOffline;
Dictionary <string, int> dicAddPool = new Dictionary <string, int>();
dicAddPool = this.dicAddressesPool;
foreach (var item in dicAddPool)
{
XXPSocketsModel RcvMod = this.XXPSendMessage(item.Key, sendMod, 3000);
}
}
public List <string> RequestMoreNodes(string ip)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
XXPSocketsModel RcvMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.NewAddresses;
RcvMod = this.XXPSendMessage(ip, sendMod);
List <string> lstIpAddress = new List <string>();
if (!string.IsNullOrEmpty(RcvMod.Value))
{
lstIpAddress = (from x in RcvMod.Value.Split('|')
where x != ""
select x).ToList();
}
LogHelper.WriteMethodLog(false);
return(lstIpAddress);
}
public bool RequestHandshake(string ip)
{
LogHelper.WriteMethodLog(true);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.Handshake;
sendMod.Value = ConstHelper.BC_RequestHandshake;
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod, 5000);
if (RcvMod.Value == ConstHelper.BC_ReturnHandshake)
{
this.Add2AddressPool(RcvMod.IpAddress);
LogHelper.WriteInfoLog("RequestHandshake succ");
return(true);
}
LogHelper.WriteInfoLog("RequestHandshake failed");
return(false);
}
private string handleReplyPriTx(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
Task.Run(() => {
if (string.IsNullOrEmpty(socketMod.Value) || socketMod.Value == Decision.Reject)
{
this.ReplyPriTxCallBack(null, socketMod.IpAddress);
}
else
{
Transaction tx = new Transaction();
tx = JsonHelper.Deserialize <Transaction>(socketMod.Value);
this.ReplyPriTxCallBack(tx, socketMod.IpAddress);
}
});
LogHelper.WriteMethodLog(false);
return(ConstHelper.BC_OK);
}
public string SendNewBlock(string ip, Block block)
{
LogHelper.WriteMethodInfoLog(ip, block.Hash);
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.NewBlock;
sendMod.Value = JsonHelper.Serializer <Block>(block);
XXPSocketsModel RcvMod = this.XXPSendMessage(ip, sendMod, 20000);
//add by fdp 181228
if (RcvMod.Type == XXPCoinMsgType.Exception)
{
return(Decision.Reject);
}
else
{
LogHelper.WriteInfoLog(string.Format("SendNewBlock to {0} return: {1}", ip, RcvMod.Value));
return(RcvMod.Value);
}
}
private string handleNewBlock(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
Block block = new Block();
if (!string.IsNullOrEmpty(socketMod.Value))
{
block = JsonHelper.Deserialize <Block>(socketMod.Value);
}
string sRet = this.NewBlockCallBack(block);
if (sRet == Decision.Accept)
{
Task.Run(() => {
this.SendNewBlock2AddressLst(block);
});
}
LogHelper.WriteInfoLog("handleNewBlock retrun: " + sRet);
return(sRet);
}
public string GetNewBlocks(string ip, Block lastBlock)
{
LogHelper.WriteMethodLog(true);
RequestBlock ReqBkInfo = new RequestBlock();
ReqBkInfo.RequestType = BlockRequestType.GetNewBlocks;
ReqBkInfo.LastBlockHash = lastBlock.Hash;
ReqBkInfo.LastBlockHeight = lastBlock.Header.Height;
XXPSocketsModel sendMod = new XXPSocketsModel();
sendMod.Type = XXPCoinMsgType.SyncBlocks;
sendMod.Value = JsonHelper.Serializer <RequestBlock>(ReqBkInfo);
XXPSocketsModel RetMod = this.SocketsHelp.XXPSendMessage(ip, sendMod, AppSettings.XXPCommport);
LogHelper.WriteInfoLog("GetNewBlocks return: " + RetMod.Value);
return(RetMod.Value);
}
private string handleNewtransactions(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
Transaction tx = new Transaction();
if (!string.IsNullOrEmpty(socketMod.Value))
{
tx = JsonHelper.Deserialize <Transaction>(socketMod.Value);
}
string sRet = this.NewTransactionCallBack(tx);
if (sRet == Decision.Accept)
{
Task.Run(() => {
this.SendNewTx2AddressLst(tx);
});
}
LogHelper.WriteInfoLog("handleNewtransactions ret: " + sRet);
return(sRet);
}
private string handleNewAddress(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
string strRet = string.Empty;
if (string.IsNullOrEmpty(socketMod.Value))// give my addresspool to sender
{
Dictionary <string, int> dicAddPool = new Dictionary <string, int>();
dicAddPool = this.dicAddressesPool;
foreach (var item in dicAddPool)
{
strRet += item.Key + "|";
}
return(strRet);
}
else // sender give his new addresses to me, handshake every one if dont contain
{
List <string> lstIpAddress = new List <string>();
if (!string.IsNullOrEmpty(socketMod.Value))
{
lstIpAddress = (from x in socketMod.Value.Split('|')
where x != ""
select x).ToList();
}
foreach (var item in lstIpAddress)
{
if (item == OSHelper.GetLocalIP())
{
continue;
}
if (!this.dicAddressesPool.ContainsKey(item))
{
this.RequestHandshake(item);
}
}
LogHelper.WriteMethodLog(true);
return("ths");
}
}
private string HandlleDBfileEvent(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
string strRet = string.Empty;
switch (socketMod.Value)
{
case DBRequestType.RequestDBInfo:
strRet = GetDBfileInfo();
break;
case DBRequestType.StratTransfer:
strRet = StartSendDBZip(socketMod.IpAddress); // start file transfer, 181211
break;
default:
break;
}
LogHelper.WriteMethodLog(true);
return(strRet);
}
private string HandlleHandshakeEvent(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
string sRet = string.Empty;
if (socketMod.Value == ConstHelper.BC_RequestHandshake)
{
sRet = ConstHelper.BC_ReturnHandshake;
if (!this.dicAddressesPool.ContainsKey(socketMod.IpAddress))
{
this.Add2AddressPool(socketMod.IpAddress);
// send this to others ... 181210
List <string> lstTemp = new List <string>();
lstTemp.Add(socketMod.IpAddress);
Task.Run(() => {
this.SendNewAddress2Others(lstTemp);
});
}
}
LogHelper.WriteMethodLog(false);
return(sRet);
}
private string HandlleHandshakeEvent(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
string sRet = string.Empty;
if (socketMod.Value == ConstHelper.BC_RequestHandshake)
{
sRet = ConstHelper.BC_ReturnHandshake;
if (!this.dicAddressesPool.ContainsKey(socketMod.IpAddress))
{
this.Add2AddressPool(socketMod.IpAddress);
// send this to others ... 181210
List <string> lstTemp = new List <string>();
lstTemp.Add(socketMod.IpAddress);
Task.Run(() => {
//modify by fdp 181231 放在外面push，只要握手成功就push，避免对方掉线重新连接，没有push
//this.PushLastBlockCallBack(socketMod.IpAddress);
//this.PushTxhsPoolCallBack(socketMod.IpAddress);
this.SendNewAddress2Others(lstTemp);
});
}
Task.Run(() =>
{
this.PushLastBlockCallBack(socketMod.IpAddress);
this.PushTxhsPoolCallBack(socketMod.IpAddress);
});
}
else if (socketMod.Value == ConstHelper.BC_NotifyOffline)
{
this.RemoveAddressFromPool(socketMod.IpAddress);
sRet = ConstHelper.BC_ResponseOffline;
}
LogHelper.WriteMethodLog(false);
return(sRet);
}
private string handleSyncBlocks(XXPSocketsModel socketMod)
{
LogHelper.WriteMethodLog(true);
RequestBlock ReqBkInfo = JsonHelper.Deserialize <RequestBlock>(socketMod.Value);
ReqBkInfo.IP = socketMod.IpAddress;
string strRet = string.Empty;
switch (ReqBkInfo.RequestType)
{
case BlockRequestType.RequestBlockInfo:
strRet = CheckBlock(ReqBkInfo);
break;
case BlockRequestType.GetNewBlocks:
strRet = StartSendBlocks(ReqBkInfo);
break;
default:
break;
}
LogHelper.WriteInfoLog("handleSyncBlocks ret: " + strRet);
return(strRet);
}
public XXPSocketsModel XXPSendMessage(string ip, XXPSocketsModel Request, int iTimeout)
{
return(this.SocketsHelp.XXPSendMessage(ip, Request, AppSettings.XXPCommport, iTimeout));
}
