private BaseBlockInfo UpdateBlockInfo(Block block)
{
var txsysfee = (int)block.Transactions.Select(t => t.SystemFee).Sum();
var txnetfee = (int)Block.CalculateNetFee(block.Transactions);
var txoutvalues = (int)block.Transactions.Select(t => t.Outputs.Select(o => o.Value)).SelectMany(x => x).Sum();
BaseBlockInfo newBlockInfo = null;
if (_netSettings.Net == NetConstants.MAIN_NET)
{
var info = _ctx.MainNetBlockInfos.FirstOrDefault(x => x.BlockHeight == block.Header.Index);
if (info == null)
{
var dbInfo = new MainNetBlockInfo
{
BlockHeight = block.Header.Index,
SecondsCount = 20,
TxCount = block.Transactions.Length,
TxSystemFees = txsysfee,
TxNetworkFees = txnetfee,
TxOutputValues = txoutvalues
};
_ctx.MainNetBlockInfos.Add(dbInfo);
_ctx.SaveChanges();
newBlockInfo = dbInfo;
}
}
else
{
var info = _ctx.TestNetBlockInfos.FirstOrDefault(x => x.BlockHeight == block.Header.Index);
if (info == null)
{
var dbInfo = new TestNetBlockInfo
{
BlockHeight = block.Header.Index,
SecondsCount = 20,
TxCount = block.Transactions.Length,
TxSystemFees = txsysfee,
TxNetworkFees = txnetfee,
TxOutputValues = txoutvalues
};
_ctx.TestNetBlockInfos.Add(dbInfo);
_ctx.SaveChanges();
newBlockInfo = dbInfo;
}
}
return(newBlockInfo);
}
private void SyncCacheAndDb()
{
foreach (var cacheNode in _nodeCache.NodeList)
{
var existingDbNode = CachedDbNodes
.FirstOrDefault(dbn => dbn.NodeAddresses.Any(ia => ia.Ip == cacheNode.Ip));
if (existingDbNode == null)
{
var newDbNode = Mapper.Map <Node>(cacheNode);
newDbNode.Type = NodeAddressType.P2P_TCP;
newDbNode.Net = _netsettings.Value.Net;
_ctx.Nodes.Add(newDbNode);
_ctx.SaveChanges();
var nodeDbAddress = new NodeAddress
{
Ip = cacheNode.Ip,
Port = cacheNode.Port,
Type = NodeAddressType.P2P_TCP,
NodeId = newDbNode.Id
};
_ctx.NodeAddresses.Add(nodeDbAddress);
_ctx.SaveChanges();
}
else
{
var portIsDifferent = existingDbNode.NodeAddresses.FirstOrDefault(na => na.Port == cacheNode.Port) == null;
if (portIsDifferent)
{
var nodeDbAddress = new NodeAddress
{
Ip = cacheNode.Ip,
Port = cacheNode.Port,
Type = NodeAddressType.P2P_TCP,
NodeId = existingDbNode.Id
};
_ctx.NodeAddresses.Add(nodeDbAddress);
_ctx.SaveChanges();
}
}
}
}
private void SeedNodesByNetType(string net)
{
var mainNodes = ((JArray)JsonConvert.DeserializeObject(File.ReadAllText($@"seed-{net.ToLower()}.json"))).ToObject <List <NodeViewModel> >();
foreach (var node in mainNodes)
{
var newNode = new Node
{
Id = 0,
Net = net,
Locale = node.Locale,
Location = node.Location,
Protocol = node.Protocol,
Url = node.Url,
Type = Enum.Parse <NodeAddressType>(node.Type),
Version = node.Version
};
_ctx.Nodes.Add(newNode);
_ctx.SaveChanges();
RegisterIpAddresses(newNode.Id, node);
}
}
private void HandleNewPeerIp(string address, StateOfNeoContext db)
{
var existingAddress = db.NodeAddresses
.Include(x => x.Node)
.FirstOrDefault(x => x.Ip.ToMatchedIp() == address.ToMatchedIp());
if (existingAddress != null)
{
var newPeer = new Peer
{
Ip = address,
FlagUrl = existingAddress.Node.FlagUrl,
Locale = existingAddress.Node.Locale,
Latitude = existingAddress.Node.Latitude,
Longitude = existingAddress.Node.Longitude,
Location = existingAddress.Node.Location,
NodeId = existingAddress.NodeId
};
this.nodeCache.AddPeerToCache(newPeer);
var peerModel = AutoMapper.Mapper.Map <PeerViewModel>(newPeer);
this.peersHub.Clients.All.SendAsync("new", peerModel);
}
else if (!db.Peers.Any(x => x.Ip == address))
{
var location = LocationCaller.GetIpLocation(address).GetAwaiter().GetResult();
if (location != null)
{
var newPeer = new Peer
{
Ip = address,
FlagUrl = location.Location.Flag,
Locale = location.Location.Languages?.FirstOrDefault().Code,
Latitude = location.Latitude,
Longitude = location.Longitude,
Location = location.CountryName
};
db.Peers.Add(newPeer);
db.SaveChanges();
this.nodeCache.AddPeerToCache(newPeer);
var peerModel = AutoMapper.Mapper.Map <PeerViewModel>(newPeer);
this.peersHub.Clients.All.SendAsync("new", peerModel);
this.peersHub.Clients.All.SendAsync("total-tracked", this.nodeCache.GetCachedPeersCount);
}
}
}
public static void Nep5CreatorUpdate(StateOfNeoContext db)
{
var scs = db.SmartContracts.ToList();
var nepAssets = db.Assets
.Where(x => x.CreatorAddressId == null)
.Where(x => !x.GlobalType.HasValue)
.Where(x => x.Type == StateOfNeo.Common.Enums.AssetType.NEP5)
.ToList();
var nepScAssets = nepAssets
.Select(x =>
{
var sc = scs.FirstOrDefault(y => y.Hash == x.Hash);
return(new
{
Asset = x,
SmartContract = sc
});
})
.ToList();
for (int i = 0; i < nepScAssets.Count; i++)
{
var assetContract = nepScAssets[i];
var testTxId = db.InvocationTransactions
.FirstOrDefault(x => x.SmartContractId == assetContract.SmartContract.Id);
var addressInTransactions = db.AddressesInTransactions
.Include(x => x.Transaction)
.Where(x => x.TransactionHash == testTxId.TransactionHash)
.ToList();
var creatorAddress = addressInTransactions.Count > 1 ?
addressInTransactions.FirstOrDefault(x => x.Amount <= 0) :
addressInTransactions.FirstOrDefault();
if (creatorAddress != null)
{
var asset = assetContract.Asset;
asset.CreatorAddressId = creatorAddress.AddressPublicAddress;
db.Assets.Update(asset);
}
}
db.SaveChanges();
}
private async Task UpdateNodesInformation()
{
var dbNodes = _ctx.Nodes
.Include(n => n.NodeAddresses)
.Where(n => n.Net.ToLower() == _netsettings.Value.Net.ToLower())
.ToList();
foreach (var dbNode in dbNodes)
{
if (dbNode.Type != NodeAddressType.REST)
{
var oldSuccessUrl = dbNode.SuccessUrl;
var newHeight = await _rPCNodeCaller.GetNodeHeight(dbNode);
if (newHeight != null)
{
dbNode.Type = NodeAddressType.RPC;
dbNode.Height = newHeight;
var newVersion = await _rPCNodeCaller.GetNodeVersion(dbNode);
dbNode.Version = newVersion;
await _locationCaller.UpdateNodeLocation(dbNode.Id);
//var peers = await _rPCNodeCaller.GetNodePeers(dbNode);
//if (peers != null)
//{
// dbNode.Peers = peers.Connected.Count();
//}
if (string.IsNullOrEmpty(dbNode.Net))
{
dbNode.Net = _netsettings.Value.Net;
}
_ctx.Nodes.Update(dbNode);
_ctx.SaveChanges();
}
}
}
UpdateDbCache();
}
private void EnsureAllContractsFromLastSnapshot()
{
var snapshot = Blockchain.Singleton.GetSnapshot();
var contracts = snapshot.Contracts;
var contractsList = contracts.Find();
foreach (var sc in contractsList)
{
if (this.db.SmartContracts.Any(x => x.Hash == sc.Value.ScriptHash.ToString()))
{
continue;
}
if (sc.Value == null)
{
Log.Information($"Tryed to create not existing contract with hash: {sc.Value.ScriptHash}. Timestamp: {1}");
continue;
}
var newSc = new SmartContract
{
Author = sc.Value.Author,
CreatedOn = DateTime.UtcNow,
Description = sc.Value.Description,
Email = sc.Value.Email,
HasDynamicInvoke = sc.Value.HasDynamicInvoke,
Hash = sc.Value.ScriptHash.ToString(),
HasStorage = sc.Value.HasStorage,
InputParameters = string.Join(",", sc.Value.ParameterList.Select(x => x)),
Name = sc.Value.Name,
Payable = sc.Value.Payable,
ReturnType = sc.Value.ReturnType,
//find stamp !!
//Timestamp = sc.Value.timestamp,
Version = sc.Value.CodeVersion
};
db.SmartContracts.Add(newSc);
db.SaveChanges();
}
}
private void HandleNewAddress(RPCPeer address, StateOfNeoContext db)
{
var newNode = default(Node);
string successUrl = null;
var ports = this.netSettings.GetPorts();
foreach (var portWithType in ports)
{
var url = portWithType.GetFullUrl(address.Address.ToMatchedIp());
try
{
var rpcResult = RpcCaller.MakeRPCCall <RPCResponseBody <int> >(url, "getblockcount")
.GetAwaiter()
.GetResult();
if (rpcResult?.Result > 0)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
portWithType.Type,
successUrl,
NodeAddressType.RPC);
break;
}
}
catch (Exception e)
{
Log.Error($"Get blockcount parse error {e.Message}", e);
break;
}
}
if (newNode == default(Node))
{
var httpTypes = new string[] { "https", "http" };
foreach (var httpType in httpTypes)
{
var url = $"{httpType}://{address.Address.ToMatchedIp()}";
var heightResponse = HttpRequester.MakeRestCall <HeightResponseObject>($@"{url}/api/main_net/v1/get_height", HttpMethod.Get)
.GetAwaiter()
.GetResult();
if (heightResponse != null)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
httpType,
successUrl,
NodeAddressType.REST,
NodeCallsConstants.NeoScan);
break;
}
var versionResponse = HttpRequester.MakeRestCall <NeoNotificationVersionResponse>($@"{url}/v1/version", HttpMethod.Get)
.GetAwaiter()
.GetResult();
if (versionResponse != null)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
httpType,
successUrl,
NodeAddressType.REST,
NodeCallsConstants.NeoNotification);
break;
}
}
}
if (newNode != null)
{
var newNodeAddress = new NodeAddress
{
Ip = address.Address.ToMatchedIp(),
Node = newNode
};
var peer = db.Peers.FirstOrDefault(x => x.Ip == address.Address.ToMatchedIp());
var result = LocationCaller.UpdateNode(newNode, newNodeAddress.Ip).GetAwaiter().GetResult();
newNode.NodeAddresses.Add(newNodeAddress);
db.NodeAddresses.Add(newNodeAddress);
db.Nodes.Add(newNode);
peer.Node = newNode;
db.SaveChanges();
}
}
protected override void OnReceive(object message)
{
if (message is PersistCompleted m)
{
if (this.lastUpdateStamp == null ||
this.lastUpdateStamp.Value.ToUnixDate().AddMinutes(MinutesPerAudit) <= m.Block.Timestamp.ToUnixDate())
{
if (this.lastUpdateStamp == null)
{
this.lastUpdateStamp = m.Block.Timestamp;
}
var optionsBuilder = new DbContextOptionsBuilder <StateOfNeoContext>();
optionsBuilder.UseSqlServer(this.connectionString, opts => opts.CommandTimeout((int)TimeSpan.FromMinutes(10).TotalSeconds));
var db = new StateOfNeoContext(optionsBuilder.Options);
var previousBlock = Blockchain.Singleton.GetBlock(m.Block.PrevHash);
var previousBlockTime = previousBlock.Timestamp.ToUnixDate();
var nodes = db.Nodes
.Include(x => x.NodeAddresses)
.Include(x => x.Audits)
.Where(x => x.Net == this.net)
.ToList();
foreach (var node in nodes)
{
var successUrl = node.SuccessUrl;
var audit = this.NodeAudit(node, m.Block);
if (audit != null)
{
db.NodeAudits.Add(audit);
node.LastAudit = m.Block.Timestamp;
}
if (string.IsNullOrEmpty(successUrl) || (!node.Longitude.HasValue && !node.Latitude.HasValue))
{
foreach (var address in node.NodeAddresses)
{
var result = LocationCaller.UpdateNode(node, address.Ip).GetAwaiter().GetResult();
var peerById = db.Peers.FirstOrDefault(x => x.NodeId == node.Id);
if (result && peerById == null)
{
var peer = db.Peers.FirstOrDefault(x => x.Ip == address.Ip);
if (peer != null)
{
peer.NodeId = node.Id;
}
else
{
var newPeer = CreatePeerFromNode(node, address.Ip);
db.Peers.Add(newPeer);
}
break;
}
else if (peerById != null)
{
if (!peerById.Longitude.HasValue && !peerById.Latitude.HasValue)
{
peerById.FlagUrl = node.FlagUrl;
peerById.Locale = node.Locale;
peerById.Latitude = node.Latitude;
peerById.Longitude = node.Longitude;
peerById.Location = node.Location;
}
}
}
}
db.Nodes.Update(node);
db.SaveChanges();
}
this.lastUpdateStamp = m.Block.Timestamp;
this.totalSecondsElapsed = null;
}
}
}