private void Mempool_OnTransactionFailed(Hash hash)
{
if (!Running || _mempool == null)
{
return;
}
var status = _mempool.GetTransactionStatus(hash, out string reason);
Logger.Warning($"Rejected transaction {hash} => " + reason);
}
private void WebLogMapper(string protocol, LunarLabs.WebServer.Core.LogLevel level, string text)
{
if (!Settings.Node.WebLogs)
{
return;
}
text = $"{protocol} {text}";
switch (level)
{
case LunarLabs.WebServer.Core.LogLevel.Debug: Logger.Debug(text); break;
case LunarLabs.WebServer.Core.LogLevel.Error: Logger.Error(text); break;
case LunarLabs.WebServer.Core.LogLevel.Warning: Logger.Warning(text); break;
default: Logger.Message(text); break;
}
}
public void ExecuteAPI(string name, string[] args)
{
var result = _nexusApi.Execute(name, args);
if (result == null)
{
Logger.Warning("API returned null value...");
return;
}
Logger.Message(result);
}
private PeerCaps SetupPeerCaps()
{
PeerCaps caps = PeerCaps.None;
if (Settings.Node.HasSync)
{
caps |= PeerCaps.Sync;
}
if (Settings.Node.HasEvents)
{
caps |= PeerCaps.Events;
}
if (Settings.Node.HasRelay)
{
caps |= PeerCaps.Relay;
}
if (Settings.Node.HasArchive)
{
caps |= PeerCaps.Archive;
}
if (Settings.Node.HasRpc)
{
caps |= PeerCaps.RPC;
}
if (Settings.Node.HasRest)
{
caps |= PeerCaps.REST;
}
if (Settings.Node.HasMempool)
{
if (Settings.Node.Readonly)
{
Logger.Warning("Mempool will be disabled due to read-only mode");
}
else
{
caps |= PeerCaps.Mempool;
}
}
var possibleCaps = Enum.GetValues(typeof(PeerCaps)).Cast <PeerCaps>().ToArray();
foreach (var cap in possibleCaps)
{
if (cap != PeerCaps.None && caps.HasFlag(cap))
{
Logger.Message("Feature enabled: " + cap);
}
}
return(caps);
}
private NexusAPI SetupNexusApi()
{
var apiCache = Settings.Node.ApiCache;
var apiLog = Settings.Node.ApiLog;
var apiProxyURL = Settings.Node.ApiProxyUrl;
var readOnlyMode = Settings.Node.Readonly;
var hasRPC = Settings.Node.HasRpc;
var hasREST = Settings.Node.HasRest;
NexusAPI nexusApi = new NexusAPI(_nexus, apiCache, apiLog ? Logger : null);
if (apiProxyURL != null)
{
nexusApi.ProxyURL = apiProxyURL;
// TEMP Normal node needs a proxy url set to relay transactions to the BPs
nexusApi.Node = _node;
Logger.Message($"API will be acting as proxy for {apiProxyURL}");
}
else
{
nexusApi.Node = _node;
}
if (readOnlyMode)
{
Logger.Warning($"Node will be running in read-only mode.");
}
else
{
nexusApi.Mempool = _mempool;
}
// RPC setup
if (hasRPC)
{
var rpcPort = Settings.Node.RpcPort;
Logger.Message($"RPC server listening on port {rpcPort}...");
var rpcServer = new RPCServer(nexusApi, "/rpc", rpcPort, (level, text) => WebLogMapper("rpc", level, text));
rpcServer.StartInThread(ThreadPriority.AboveNormal);
}
// REST setup
if (hasREST)
{
var restPort = Settings.Node.RestPort;
Logger.Message($"REST server listening on port {restPort}...");
var restServer = new RESTServer(nexusApi, "/api", restPort, (level, text) => WebLogMapper("rest", level, text));
restServer.StartInThread(ThreadPriority.AboveNormal);
}
return(nexusApi);
}
private Node SetupNode()
{
if (Settings.Node.Mode == NodeMode.Proxy)
{
Logger.Warning("No nexus will be setup locally due to proxy mode being enabled");
return(null);
}
Node node = null;
if (this._mempool != null)
{
this._mempool.SetKeys(_nodeKeys);
}
if (!Settings.Node.IsValidator && Settings.Node.Seeds.Count == 0 && _peerCaps.HasFlag(PeerCaps.Sync))
{
throw new Exception("A non-validator node with sync enabled must specificy a non-empty list of seed endpoints");
}
node = new Node("Spook v" + Version
, _nexus
, _mempool
, _nodeKeys
, Settings.Node.NodeHost
, _availablePorts
, _peerCaps
, Settings.Node.Seeds
, Logger);
var missingNexus = !_nexus.HasGenesis;
if (missingNexus)
{
if (Settings.Node.IsValidator)
{
var nexusName = Settings.Node.NexusName;
if (Settings.Node.NexusBootstrap)
{
if (!ValidationUtils.IsValidIdentifier(nexusName))
{
Logger.Error("Invalid nexus name: " + nexusName);
this.Terminate();
}
Logger.Message($"Boostraping {nexusName} nexus using {_nodeKeys.Address}...");
var genesisTimestamp = Settings.Node.GenesisTimestamp;
if (!_nexus.CreateGenesisBlock(_nodeKeys, genesisTimestamp, DomainSettings.LatestKnownProtocol))
{
throw new ChainException("Genesis block failure");
}
Logger.Success("Genesis block created: " + _nexus.GetGenesisHash(_nexus.RootStorage));
missingNexus = false;
}
}
else
{
if (_mempool != null)
{
_mempool.SubmissionCallback = (tx, chain) =>
{
Logger.Message($"Relaying tx {tx.Hash} to other node");
};
}
}
if (missingNexus && !_peerCaps.HasFlag(PeerCaps.Sync))
{
Logger.Error("No Nexus found.");
this.Terminate();
}
}
else
{
var genesisAddress = _nexus.GetGenesisAddress(_nexus.RootStorage);
if (Settings.Node.IsValidator && !Settings.Node.Readonly)
{
if (!_nexus.IsKnownValidator(_nodeKeys.Address))
{
throw new Exception("Specified node key does not match a known validator address");
}
else
if (_nodeKeys.Address != genesisAddress)
{
Logger.Warning("Specified node key does not match genesis address " + genesisAddress.Text);
}
}
var chainHeight = _nexus.RootChain.Height;
var genesisHash = _nexus.GetGenesisHash(_nexus.RootStorage);
Logger.Success($"Loaded {Nexus.Name} Nexus with genesis {genesisHash } with {chainHeight} blocks");
}
return(node);
}
