public BaseTest()
{
Login = new Dictionary <string, string>()
{
{ "Steem", "UserLogin" },
{ "Golos", "UserLogin" }
};
UserPrivateKeys = new Dictionary <string, List <byte[]> >()
{
{ "Steem", new List <byte[]> {
Base58.TryGetBytes("5**************************************************")
} },
{ "Golos", new List <byte[]> {
Base58.TryGetBytes("5**************************************************")
} }
};
Chain = new Dictionary <string, ChainInfo>();
var steemChainInfo = ChainManager.GetChainInfo(KnownChains.Steem);
Chain.Add("Steem", steemChainInfo);
Steem = new OperationManager(steemChainInfo.Url, steemChainInfo.ChainId);
var golosChainInfo = ChainManager.GetChainInfo(KnownChains.Golos);
Chain.Add("Golos", golosChainInfo);
Golos = new OperationManager(golosChainInfo.Url, golosChainInfo.ChainId);
}
public OperationManagerTest()
{
_login = new Dictionary <string, string>()
{
{ "Steem", "Test Login" },
{ "Golos", Constants.GolosUser }
};
_userPrivateKeys = new Dictionary <string, List <byte[]> >()
{
{ "Steem", new List <byte[]> {
Base58.GetBytes(Constants.SteemPostingKey)
} },
{ "Golos", new List <byte[]> {
Base58.GetBytes(Constants.GolosPostingKey)
} }
};
_chain = new Dictionary <string, ChainInfo>();
var steemChainInfo = ChainManager.GetChainInfo(KnownChains.Steem);
_chain.Add("Steem", steemChainInfo);
_steem = new OperationManager(steemChainInfo.Url, steemChainInfo.ChainId);
var golosChainInfo = ChainManager.GetChainInfo(KnownChains.Golos);
_chain.Add("Golos", golosChainInfo);
_golos = new OperationManager(golosChainInfo.Url, golosChainInfo.ChainId);
}
public BlockController(ChainManager chainManager, Miner miner, ContactLedger contactLedger, HttpProvider httpProvider)
{
_chainManager = chainManager;
_miner = miner;
_contactLedger = contactLedger;
_httpProvider = httpProvider;
}
public void FollowOperation()
{
Login = new Dictionary <string, string>()
{
{ "Steem", txtUsername.Text }
};
UserPrivateKeys = new Dictionary <string, List <byte[]> >()
{
{ "Steem", new List <byte[]> {
Base58.GetBytes(txtPassword.Text)
} }
};
Chain = new Dictionary <string, ChainInfo>();
var steemChainInfo = ChainManager.GetChainInfo(KnownChains.Steem);
Chain.Add("Steem", steemChainInfo);
Steem = new OperationManager(steemChainInfo.Url, steemChainInfo.ChainId);
var op = new UnFollowOperation(txtUsername.Text, txtFollower.Text, FollowType.blog, txtUsername.Text);
var prop = Manager("Steem").VerifyAuthority(UserPrivateKeys["Steem"], op);
var propa = Manager("Steem").BroadcastOperations(UserPrivateKeys["Steem"], op);
if (propa.Error == null)
{
lblStatus.Text = "Follow user '" + txtFollower.Text + "' transaction successfully completed!";
}
else
{
lblStatus.Text = "Error follow user: " + propa.Error.Message.ToString();
}
}
//责任链
//用于多个处理对象和处理数据的解耦
//新增加处理对象的时候，只需要添加新的处理对象即可。
static void Main(string[] args)
{
Console.WriteLine(MethodBase.GetCurrentMethod().DeclaringType.Namespace);
IHandler leader = new Leader();
IHandler manager = new Manager();
IHandler director = new Director();
//Method B
ChainManager mgrChain = new ChainManager();
mgrChain.Add(leader);
mgrChain.Add(manager);
mgrChain.Add(director);
mgrChain.Handle(500);
mgrChain.Handle(1500);
mgrChain.Handle(15000);
//Method A
leader.Next = manager;
manager.Next = director;
leader.Handle(500);
leader.Handle(1500);
leader.Handle(15000);
Console.ReadKey();
}
private void LateUpdate()
{
if (applyTransforms)
{
if (target == null)
{
return;
}
// Get the chain and assert that it is not broken
Chain c = ChainManager.BuildChain(root);
Debug.Assert(!c.IsBroken());
List <Joint> joints = new List <Joint>();
for (int i = 0; i < c.BoneCount; i++)
{
joints.Add(c.GetBone(i).Base);
}
joints.Add(c.EndEffector);
Chain_FABRIK.Solve(c, target);
ChainManager.ApplyJointTransforms(root, joints);
visualizer.Show();
visualizer.SetChain(c);
}
}
//
private void Start()
{
if (root == null)
{
root = transform;
}
visualizer = new ChainManager(transform);
}
void LateUpdate()
{
if (runIK)
{
runIK = false;
if (Target == null)
{
return;
}
// Get the chain and assert that it is not broken
Chain chain = ChainManager.BuildChain(ChainRoot);
Debug.Assert(!chain.IsBroken());
var chainCopy = chain.Copy();
chainCopy.Destroy();
chain.Restore();
Chain_FABRIK.Solve(chain, Target);
ChainManager.ApplyJointTransforms(ChainRoot, chain.GetJoints());
chain = ChainManager.BuildChain(ChainRoot);
ConstraintsUtil.Constrain(chain, Target);
ChainManager.ApplyJointTransforms(ChainRoot, chain.GetJoints());
}
if (Input.GetKeyDown(KeyCode.I))
{
runIK = false;
Chain chain = ChainManager.BuildChain(ChainRoot);
chain.Restore();
Chain_FABRIK.Solve(chain, Target);
ChainManager.ApplyJointTransforms(ChainRoot, chain.GetJoints());
}
if (Input.GetKeyDown(KeyCode.R))
{
runIK = false;
Chain chain = ChainManager.BuildChain(ChainRoot);
chain.Restore();
ChainManager.ApplyJointTransforms(ChainRoot, chain.GetJoints());
}
if (Input.GetKeyDown(KeyCode.C))
{
Chain chain = ChainManager.BuildChain(ChainRoot);
ConstraintsUtil.Constrain(chain, Target);
ChainManager.ApplyJointTransforms(ChainRoot, chain.GetJoints());
}
if (Input.GetKeyDown(KeyCode.D))
{
Chain chain = ChainManager.BuildChain(ChainRoot);
DisplayChainInfo(chain);
}
}
public TextSampleForm()
{
InitializeComponent();
m_recorder = new TextEditor(textBox1);
ChainManager.IniParams iniParams = new ChainManager.IniParams();
iniParams.RecordCollection.Add(m_recorder);
iniParams.DontRecordWhenStatusError = true;
m_chainManager = new ChainManager(iniParams);
}
public ClientServer(Node.Node node)
{
_chainManager = node.ChainManager;
_configuration = node.NodeConfiguration;
_attachementManager = node.AttachementManager;
_transactionManager = node.TransactionManager;
_pubsub = node.PubSub;
_pubsub.Subscribe <BlockEvent <CoreBlock> >(this, NewCoreBlock);
_pubsub.Subscribe <BlockEvent <ServiceBlock> >(this, NewServiceBlock);
_pubsub.Subscribe <BlockEvent <DataBlock> >(this, NewDataBlock);
}
// Use this for initialization
void Start()
{
turnManager = this.gameObject.GetComponent <TurnManager>();
chainManager = this.gameObject.GetComponent <ChainManager>();
scoreManager = this.gameObject.GetComponent <ScoreManager>();
stage = new GameObject[StageSize, StageSize];
deleteTable = new bool[StageSize, StageSize];
spawner = new Spawner(ref blocks, StageSize, this.SpawnProbWeight);
spawner.InitStage(ref stage);
#if DEBUG
TotalNum = spawner.BlockInfoProp.GetTotalNum;
blockNums = spawner.BlockInfoProp.GetBlockNums;
#endif
}
/// <summary> Raises the chain geometry event. </summary>
///
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Event information to send to registered event handlers. </param>
private void OnChainGeometry(object sender, EventArgs e)
{
UtilityService.Initialize();
var chains = ChainManager.ChainGeometry(UtilityService.DrawRectangle());
if (!chains.Any())
{
UtilityService.ShowMessage("No chains returned");
return;
}
if (this.Contour(chains))
{
UtilityService.FitScreen();
}
}
public async Task <int> Run()
{
if (_quitToken.IsCancellationRequested)
{
return(0);
}
await Kademlia.Start();
TransactionManager.Start();
await CouncilManager.Start();
await NodeServer.Start();
await ClientServer.Start();
if (ServiceServer != null)
{
await ServiceServer.Start();
}
await _quitToken.WaitAsync();
await PubSub.PublishAsync(new QuitEvent());
await NodeServer.Stop();
await ClientServer.Stop();
await CouncilManager.Stop();
TransactionManager.Stop();
await Kademlia.Stop();
await ChainManager.Stop();
if (ServiceServer != null)
{
await ServiceServer.Stop();
}
await(Host as Host).Stop();
return(0);
}
public Daemon(Mutex chainMutex, ChainManager chainManager, App.ILogger logger, App.IInventoryNotifier inventoryNotifier, CancellationToken cancellationToken)
{
this.chainMutex = chainMutex;
this.chainManager = chainManager;
this.logger = logger;
this.inventoryNotifier = inventoryNotifier;
this.cancellationToken = cancellationToken;
nodeNonce = createNodeNonce();
peers = new List <Context>();
ibd = new InitialBlockDownload();
houseKeepingLock = new object();
runHouseKeeping();
}
public MultiActorSampleForm()
{
InitializeComponent();
m_textEdiorRecorder1 = new TextEditor(textBox1);
m_textEdiorRecorder2 = new TextEditor(textBox2);
ChainManager.IniParams param = new ChainManager.IniParams()
{
DontRecordWhenStatusError = true,
};
param.RecordCollection.Add(m_textEdiorRecorder1);
param.RecordCollection.Add(m_textEdiorRecorder2);
m_chainManager = new ChainManager(param);
CheckUndoRedoStatus();
}
public void ConfigureServices(IServiceCollection services)
{
var mvcCore = services.AddMvcCore();
mvcCore.AddJsonFormatters(options => options.ContractResolver = new CamelCasePropertyNamesContractResolver());
services.AddSingleton(services);
var httpProvider = new HttpProvider();
services.AddSingleton(httpProvider);
services.AddSingleton(new ContactLedger(httpProvider));
var balanceLedger = new BalanceLedger();
services.AddSingleton(balanceLedger);
var chainManager = new ChainManager(balanceLedger);
services.AddSingleton(chainManager);
var txPool = new TransactionPool(balanceLedger);
services.AddSingleton(txPool);
services.AddSingleton(new Miner(balanceLedger, txPool, chainManager));
var jobs = new List <Tuple <Type, string> >()
{
new Tuple <Type, string>(typeof(FetchContactsJob), everyMinuteCron),
new Tuple <Type, string>(typeof(FetchBlocksJob), everyMinuteCron),
new Tuple <Type, string>(typeof(TransactionPoolUpdateJob), everyMinuteCron),
};
var serviceProvider = services.BuildServiceProvider();
ScheduleJobs(jobs, serviceProvider);
if (Program.Settings.mine)
{
Program.MinerTask = Task.Run(() => StartMiner(serviceProvider));
}
}
/// <summary> Raises the chain level event. </summary>
///
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Event information to send to registered event handlers. </param>
private void OnChainLevel(object sender, EventArgs e)
{
const int Level = 5;
UtilityService.Initialize();
UtilityService.DrawBlock(new Point3D(0, 0, 0), new Point3D(10, 10, 0), -0.5, Level);
var chains = ChainManager.ChainAll(true, false, ViewManager.CPlane, ChainDirectionType.Clockwise, Level);
if (!chains.Any())
{
UtilityService.ShowMessage("No chains returned");
}
if (this.Contour(chains))
{
UtilityService.FitScreen();
}
}
/// <summary> Raises the chain all selected event. </summary>
///
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Event information to send to registered event handlers. </param>
private void OnChainAllSelected(object sender, EventArgs e)
{
UtilityService.Initialize();
UtilityService.DrawPolygon();
SelectionManager.SelectAllGeometry();
var chains = ChainManager.ChainAllSelected(true);
if (!chains.Any())
{
UtilityService.ShowMessage("No chains returned");
return;
}
if (this.Contour(chains))
{
UtilityService.FitScreen();
}
}
/// <summary> Creates contour operation. </summary>
///
/// <param name="tool"> The tool. </param>
/// <param name="chains"> The chains. </param>
///
/// <returns> The new contour operation. </returns>
internal static ContourOperation CreateContourOperation(EndMillFlatTool tool, Chain[] chains)
{
// Throw a contour around the chains
var contourOp = new ContourOperation
{
OperationTool = tool,
CutterComp =
{
Direction = CutterCompDir.CutterCompLeft,
RollCorners = CutterCompRoll.CutterCompRollAll
},
Linking =
{
Depth = -.25,
Retract = 1,
RetractOn = true,
TopStock = 0
},
SpindleSpeed = 2500,
FeedRate = 12,
NCIName = "Contour #1",
Name = "Contour operation created via API"
};
ChainManager.StartChainAtLongest(chains);
ChainManager.SortChains(chains, ChainManager.SortType.Area, ChainManager.SortOrder.Ascending);
contourOp.SetChainArray(chains);
if (!contourOp.Commit())
{
return(null);
}
contourOp.Regenerate();
return(contourOp);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
string eosNodeUrl = this.Configuration.GetValue <string>("EosNodeUrl", "");
var eosConfig = new EosConfigurator()
{
HttpEndpoint = eosNodeUrl,
ExpireSeconds = 60
};
var chainManager = new ChainManager(eosConfig);
services.AddSingleton <ChainManager>(chainManager);
services.UseTransactionsManager(this.Configuration, this.m_LoggerFactory);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
}
public void PostDataToSteemWithUpvote()
{
Login = new Dictionary <string, string>()
{
{ "Steem", txtUsername.Text }
};
UserPrivateKeys = new Dictionary <string, List <byte[]> >()
{
{ "Steem", new List <byte[]> {
Base58.GetBytes(txtPassword.Text)
} }
};
Chain = new Dictionary <string, ChainInfo>();
var steemChainInfo = ChainManager.GetChainInfo(KnownChains.Steem);
Chain.Add("Steem", steemChainInfo);
Steem = new OperationManager(steemChainInfo.Url, steemChainInfo.ChainId);
var op = new PostOperation(txtTag1.Text, txtUsername.Text, txtTitle.Text, txtResponse.Text, "{\"app\": \"steemit/0.1\", \"tags\": [\"" + txtTag2.Text + "\",\"" + txtTag3.Text + "\",\"" + txtTag4.Text + "\",\"" + txtTag5.Text + "\"]}");
var prop = Manager("Steem").VerifyAuthority(UserPrivateKeys["Steem"], op);
var propa = Manager("Steem").BroadcastOperations(UserPrivateKeys["Steem"], op);
if (propa.Error == null)
{
lblStatus.Text = "'Post to STEEM' transaction successfully completed!";
var up = new UpVoteOperation(txtUsername.Text, txtUsername.Text, op.Permlink);
var uprop = Manager("Steem").VerifyAuthority(UserPrivateKeys["Steem"], up);
var upropa = Manager("Steem").BroadcastOperations(UserPrivateKeys["Steem"], up);
}
else
{
lblStatus.Text = "Error posting on STEEM: " + propa.Error.Message.ToString();
}
}
public void PostDataToSteem()
{
Login = new Dictionary <string, string>()
{
{ "Steem", txtUsername.Text }
};
UserPrivateKeys = new Dictionary <string, List <byte[]> >()
{
{ "Steem", new List <byte[]> {
Base58.GetBytes(txtPassword.Text)
} }
};
Chain = new Dictionary <string, ChainInfo>();
var steemChainInfo = ChainManager.GetChainInfo(KnownChains.Steem);
Chain.Add("Steem", steemChainInfo);
Steem = new OperationManager(steemChainInfo.Url, steemChainInfo.ChainId);
var op = new PostOperation(txtTag1.Text, txtUsername.Text, txtTitle.Text, txtResponse.Text, "{\"app\": \"steemit/0.1\", \"tags\": [\"" + txtTag2.Text + "\",\"" + txtTag3.Text + "\",\"" + txtTag4.Text + "\",\"" + txtTag5.Text + "\"]}");
var prop = Manager("Steem").VerifyAuthority(UserPrivateKeys["Steem"], op);
var resp = Manager("Steem").GetAccountBandwidth(txtUsername.Text, BandwidthType.Post);
var Text = JsonConvert.SerializeObject(resp.Result);
var propa = Manager("Steem").BroadcastOperations(UserPrivateKeys["Steem"], op);
if (propa.Error == null)
{
lblStatus.Text = "Posted to STEEM blockchain, finished";
}
else
{
lblStatus.Text = propa.Error.Message.ToString();
}
}
public NodeServer(Node.Node node, int maxIncomingConnections, int maxOutgoingConnections)
{
_kademlia = node.Kademlia;
_chainManager = node.ChainManager;
_transactionManager = node.TransactionManager;
_node = node;
_maxIncomingConnections = maxIncomingConnections;
_maxOutgoingConnections = maxOutgoingConnections;
_connections.Add(_pendingConnections);
_connections.Add(_incomingConnections);
_connections.Add(_outgoingConnections);
foreach (var ac in node.NodeConfiguration.AutoConnectNodes)
{
_autoConnect.Add(new NodeAutoConnect(ac));
}
foreach (var id in node.NodeConfiguration.TrustedNodeIds)
{
_trustedNodeIds.Add(id);
}
}
void Start()
{
chainManager = this.GetComponent <ChainManager>();
mobileJoystickOriginalPos = mobileJoystick.transform.position;
mobileJoystickBackroundOriginalPos = mobileJoystickBackround.transform.position;
mobileChainJoystickOriginalPos = mobileChainJoystick.transform.position;
mobileChainJoystickBackroundOriginalPos = mobileChainJoystickBackround.transform.position;
if (freeTouchMovement)
{
mobileJoystick.SetActive(false);
mobileJoystickBackround.SetActive(false);
mobileChainJoystick.SetActive(false);
mobileChainJoystickBackround.SetActive(false);
}
else
{
mobileJoystick.SetActive(true);
mobileJoystickBackround.SetActive(true);
mobileChainJoystick.SetActive(true);
mobileChainJoystickBackround.SetActive(true);
}
}
// Use this for initialization
void Start()
{
chainManager = GameObject.Find("GameManager").GetComponent <ChainManager>();
}
void Start()
{
chainManager = new ChainManager(ChainRoot);
}
public ChainController(ChainManager chainManager, TransactionsManager transactionsManager)
{
m_ChainManager = chainManager;
m_TransactionsManager = transactionsManager;
}
public async Task <bool> Start(string[] args, CancellationTokenSource quiteToken)
{
_quitToken = quiteToken;
if (_quitToken.IsCancellationRequested)
{
return(false);
}
var dataPath = "heleusdata";
var genesis = false;
var sync = false;
var run = false;
var init = false;
var newChainConfig = false;
if (args.Length == 1)
{
dataPath = args[0];
run = true;
}
else if (args.Length == 2)
{
dataPath = args[0];
var cmd = args[1];
if (cmd == "init")
{
init = true;
}
else if (cmd == "run")
{
run = true;
}
else if (cmd == "sync")
{
sync = true;
}
else if (cmd == "chainconfig")
{
newChainConfig = true;
}
else if (cmd == "genesis")
{
genesis = true;
}
else
{
Usage();
return(false);
}
}
else
{
Usage();
return(false);
}
if ((run || sync) && !File.Exists(Path.Combine(dataPath, $"{nameof(NodeConfig).ToLower()}.txt")))
{
Usage();
var dp = new DirectoryInfo(dataPath);
Log.Error($"Data path {dp.FullName} not initalized.", this);
return(false);
}
Storage = new Storage(dataPath);
if (!Storage.IsWriteable)
{
Log.Fatal($"Data path {Storage.Root} is not writeable!", this);
return(false);
}
if (genesis)
{
Storage.DeleteDirectory("cache");
Storage.DeleteDirectory("chains");
}
PubSub = Log.PubSub = new PubSub();
Log.Write($"Starting Heleus Node (Version {Program.Version}).");
Log.Trace($"PID {System.Diagnostics.Process.GetCurrentProcess().Id}");
Log.Write($"Data path is '{Storage.Root.FullName}'.");
var config = Config.Load <NodeConfig>(Storage);
Log.AddIgnoreList(config.LogIgnore);
Log.LogLevel = config.LogLevel;
if (Program.IsDebugging)
{
Log.LogLevel = LogLevels.Trace;
}
if (newChainConfig)
{
var chainConfig = Config.Load <ChainConfig>(Storage, true);
//if (chainConfig.Chains.Count == 0)
{
Log.Write("Chain config generated.");
chainConfig.Chains.Add(new ChainConfig.ChainInfo {
ChainKeys = new List <ChainConfig.ChainKeyInfo> {
new ChainConfig.ChainKeyInfo {
ChainKey = string.Empty, ChainKeyPassword = string.Empty, AttachementKey = -1
}
}
});
Config.Save(chainConfig);
}
return(false);
}
if (init)
{
Log.Write("Config file generated.");
return(false);
}
if (!genesis)
{
if (config.NetworkPublicKey.IsNullOrEmpty())
{
Log.Write("Network key not set. Querying beacon nodes.");
var beacons = config.BeaconNodes;
foreach (var beacon in beacons)
{
Log.Write($"Querying beacon node {beacon}.");
var client = new NodeClient(new Uri(beacon));
var nodeInfo = (await client.DownloadNodeInfo()).Data;
if (nodeInfo != null)
{
config.NetworkPublicKey = nodeInfo.NetworkKey.HexString;
Config.Save(config);
Log.Write($"Network key set to {config.NetworkPublicKey}.");
break;
}
}
}
if (config.NetworkPublicKey.IsNullOrEmpty())
{
Log.Write("No valid network key found or set.", this);
return(false);
}
}
NodeConfiguration = new NodeConfiguration(config, Config.Load <CoreKeyConfig>(Storage, false), Config.Load <ChainConfig>(Storage, false));
Host = new Host(config);
AttachementManager = new AttachementManager(this);
ChainManager = new ChainManager(this);
if (!await ChainManager.Initalize())
{
return(false);
}
if (genesis)
{
var result = GenesisBlock.Generate(Storage);
var blockData = new BlockData <CoreBlock>(result.Block, result.Signature);
await ChainManager.Start(false);
await ChainManager.CoreChain.BlockStorage.StoreBlock(blockData);
ChainManager.ConsumeBlockData(blockData);
Log.Write($"Genesis block and keys generated. Network public key: {result.NetworkPublicKey.HexString}.");
var coreKeyConfig = Config.Load <CoreKeyConfig>(Storage);
coreKeyConfig.Key = result.NetworkVoteKey.HexString;
coreKeyConfig.Password = result.NetworkVotePassword;
config.NetworkPublicKey = result.NetworkPublicKey.HexString;
Config.Save(config);
Config.Save(coreKeyConfig);
await ChainManager.Stop();
await ChainManager.Start(true);
if (result.ServiceTransactions.Count > 0)
{
foreach (var serviceTransactions in result.ServiceTransactions)
{
var chainId = serviceTransactions.Key;
var transactions = serviceTransactions.Value;
var serviceChain = ChainManager.GetServiceChain(chainId);
var maintainChain = ChainManager.GetMaintainChain(chainId);
if (serviceChain != null)
{
var generator = new ServiceBlockGenerator(ChainManager.CoreChain, serviceChain, maintainChain, null);
foreach (var transaction in transactions)
{
generator.ConsumeTransaction(transaction);
}
var serviceBlock = generator.GenerateBlock(0, 0);
var serviceBlockData = new BlockData <ServiceBlock>(serviceBlock, new BlockSignatures(serviceBlock));
await serviceChain.BlockStorage.StoreBlock(serviceBlockData);
serviceChain.ConsumeBlockData(serviceBlockData);
}
}
}
await ChainManager.Stop();
return(false);
}
SyncManager = new SyncManager(this);
await SyncManager.Start();
//if (!await SyncManager.Start())
// return false;
if (sync)
{
Log.Write("Sync done.");
return(false);
}
AttachementManager.Start();
Kademlia = new Kademlia(Storage, this);
TransactionManager = new TransactionManager(this);
CouncilManager = new CouncilManager(this);
NodeServer = new NodeServer(this, config.MaxIncomingConnections, config.MaxOutgoingConnectoins);
ClientServer = new ClientServer(this);
if (Host.EnableRemoteServices)
{
ServiceServer = new ServiceServer();
}
await(Host as Host).Start(this);
return(true);
}
/// <summary>
/// Processes a message sent from a peer node.
/// </summary>
/// <param name="ctx">Context of the sender.</param>
/// <param name="msg">Message to process.</param>
private void onMessageReceived(Context ctx, Message msg)
{
if (!Message.VerifyChecksum(msg))
{
return;
}
if (msg.Type == MessageType.Version)
{
if (ctx.HasHandshake && ctx.Version > 0)
{
// Version should be the first message a peer sends
// and it should be sent only once.
ctx.ShouldDisconnect = true;
return;
}
var md = MessageData.FromJson <MDVersion>(msg.Data);
if (md == null)
{
ctx.ShouldDisconnect = true;
return;
}
// The node is connecting to itself.
if (md.Nonce == nodeNonce)
{
ctx.ShouldDisconnect = true;
return;
}
// Currently we decide to reject all nodes having lower version number.
if (md.Version < Config.Version)
{
ctx.ShouldDisconnect = true;
return;
}
if (ctx.HasHandshake is false)
{
logger.Log(App.LogLevel.Info, $"{ctx.ClientEndPoint} version 0x{md.Version:x8} height {md.Height}.");
ctx.Version = md.Version;
ctx.UpdateHeightIfHigher(md.Height);
if (ctx.IsOutbound)
{
sendVersionMessage(ctx);
}
else
{
sendVersionAckMessage(ctx);
}
}
return;
}
// At this point, a Version message should have been sent by the peer.
// Otherwise it is not behaving properly.
if (ctx.Version == 0)
{
ctx.ShouldDisconnect = true;
return;
}
if (msg.Type == MessageType.VersionAck)
{
var md = MessageData.FromJson <MDVersion>(msg.Data);
if (md == null)
{
ctx.ShouldDisconnect = true;
return;
}
if (ctx.HasHandshake is false)
{
ctx.HasHandshake = true;
sendVersionAckMessage(ctx);
if (ctx.IsOutbound is false)
{
logger.Log(App.LogLevel.Info, $"Successful handshake with {ctx.ClientEndPoint}. Sending GetLatestBlock.");
ibd.MarkPeerReady(ctx);
ibd.MarkRequestTime(ctx);
sendGetLatestBlockMessage(ctx);
}
}
return;
}
if (ctx.HasHandshake is false)
{
logger.Log(App.LogLevel.Warning, $"{ctx.ClientEndPoint} sent something before ver/verack. Marked for disconnection.");
ctx.ShouldDisconnect = true;
return;
}
if (msg.Type == MessageType.GetLatestBlock)
{
// Ignore this when IBD is not done
if (ibd.IsDone is false)
{
return;
}
var md = MessageData.FromJson <MDGetLatestBlock>(msg.Data);
if (md == null)
{
ctx.ShouldDisconnect = true;
return;
}
if (chainMutex.WaitOne(millisecondsTimeout: 3000) is false)
{
logger.Log(App.LogLevel.Warning, "chainMutex was held too long.");
return;
}
logger.Log(App.LogLevel.Info, $"{ctx.ClientEndPoint} sent GetLatestBlock. Responding.");
sendLatestBlockMessage(ctx, chainManager.LatestBlock);
chainMutex.ReleaseMutex();
return;
}
if (msg.Type == MessageType.LatestBlock)
{
var md = MessageData.FromJson <MDLatestBlock>(msg.Data);
if (md == null)
{
ctx.ShouldDisconnect = true;
return;
}
if (md.Block == null)
{
ctx.ShouldDisconnect = true;
return;
}
if (!ChainManager.ValidateBlockSanity(md.Block))
{
ctx.ShouldDisconnect = true;
return;
}
logger.Log(App.LogLevel.Info, $"{ctx.ClientEndPoint} sent LatestBlock.");
if (ibd.CurrentPhase == InitialBlockDownload.Phase.Preparing)
{
ibd.ReceiveLatestBlock(ctx, md.Block);
// If all peers have sent LatestBlock, we'll proceed IBD
if (ibd.AllPeersResponded() is true)
{
logger.Log(App.LogLevel.Info, "All connected peers have sent latest blocks. Starting IBD.");
startIbd();
}
}
else
{
var blocksToAdd = ctx.GetStoredAndNewBlocks(md.Block);
ctx.UpdateHeightIfHigher(blocksToAdd[^ 1].Index);
public void ProcessTransactions()
{
Program.CheckFolderStructure();
Program.Settings = new Settings("settings.json");
if (File.Exists("balance"))
{
File.Delete("balance");
}
if (File.Exists("nonces"))
{
File.Delete("nonces");
}
foreach (var file in Directory.GetFiles("chains"))
{
File.Delete(file);
}
foreach (var file in Directory.GetFiles("tables"))
{
File.Delete(file);
}
var walletA = new Wallet();
var walletB = new Wallet();
var walletC = new Wallet();
var walletD = new Wallet();
var walletE = new Wallet();
var walletF = new Wallet();
var walletM = new Wallet(); //miner
var balanceLedger = new BalanceLedger();
var manager = new ChainManager(balanceLedger);
var contacts = new ContactLedger(new HttpProvider());
//generate first blocks
var minedBlocks = new List <Block>();
minedBlocks.Add(CreateNextBlock(Block.Genesis, null, walletA.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[0], null, walletA.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[1], null, walletA.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[2], null, walletB.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[3], null, walletB.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[4], null, walletB.PublicKey));
minedBlocks.Add(CreateNextBlock(minedBlocks[5], null, walletB.PublicKey));
manager.ProcessBlocks(minedBlocks);
var transactions = new List <Transaction>()
{
CreateTransaction(walletA, walletD, 100, 0),
CreateTransaction(walletB, walletF, 200, 0),
CreateTransaction(walletA, walletB, 400, 1),
CreateTransaction(walletB, walletD, 800, 1),
CreateTransaction(walletA, walletD, 1600, 2)
};
var txBlock = CreateNextBlock(minedBlocks[minedBlocks.Count - 1], transactions);
manager.ProcessBlocks(new List <Block>()
{
txBlock
});
Assert.IsTrue(manager.GetBalance(walletA.PublicKey) == (Program.MinerReward * 3 - 100 - 400 - 1600 - 60));
Assert.IsTrue(manager.GetBalance(walletB.PublicKey) == (Program.MinerReward * 4 - 200 - 800 - 40 + 400));
Assert.IsTrue(manager.GetTransactionCount(walletA.PublicKey) == 3);
Assert.IsTrue(manager.GetTransactionCount(walletB.PublicKey) == 2);
var paddingBlocks = new List <Block>();
paddingBlocks.Add(CreateNextBlock(txBlock, new List <Transaction>()
{
CreateTransaction(walletB, walletF, 3200, 2)
}, walletA.PublicKey));
paddingBlocks.Add(CreateNextBlock(paddingBlocks[0], new List <Transaction>()
{
CreateTransaction(walletA, walletE, 6400, 3)
}, walletA.PublicKey));
paddingBlocks.Add(CreateNextBlock(paddingBlocks[1], new List <Transaction>()
{
CreateTransaction(walletA, walletB, 12800, 4),
CreateTransaction(walletD, walletC, 2400, 0)
}, walletA.PublicKey));
manager.ProcessBlocks(paddingBlocks);
Assert.IsTrue(manager.GetBalance(walletA.PublicKey) == (Program.MinerReward * 6 - 100 - 400 - 1600 - 6400 - 12800 - 100));
Assert.IsTrue(manager.GetBalance(walletB.PublicKey) == (Program.MinerReward * 4 - 200 - 800 - 3200 - 60 + 400 + 12800));
Assert.IsTrue(manager.GetBalance(walletC.PublicKey) == 2400);
Assert.IsTrue(manager.GetBalance(walletD.PublicKey) == 100 + 800 + 1600 - 2400 - 20);
Assert.IsTrue(manager.GetBalance(walletE.PublicKey) == 6400);
Assert.IsTrue(manager.GetBalance(walletF.PublicKey) == 200 + 3200);
var forkBlocks = new List <Block>();
forkBlocks.Add(CreateNextBlock(paddingBlocks[0], new List <Transaction>()
{
CreateTransaction(walletA, walletB, 2400, 3),
CreateTransaction(walletD, walletC, 1200, 0)
}, walletE.PublicKey));
forkBlocks.Add(CreateNextBlock(forkBlocks[0], new List <Transaction>(), walletE.PublicKey));
forkBlocks.Add(CreateNextBlock(forkBlocks[1], new List <Transaction>(), walletE.PublicKey));
forkBlocks.Add(CreateNextBlock(forkBlocks[2], new List <Transaction>(), walletE.PublicKey));
manager.ProcessBlocks(forkBlocks);
Assert.IsTrue(manager.GetBalance(walletA.PublicKey) == (Program.MinerReward * 4 - 100 - 400 - 1600 - 2400 - 80));
Assert.IsTrue(manager.GetBalance(walletB.PublicKey) == (Program.MinerReward * 4 - 200 - 800 - 3200 - 60 + 400 + 2400));
Assert.IsTrue(manager.GetBalance(walletC.PublicKey) == 1200);
Assert.IsTrue(manager.GetBalance(walletD.PublicKey) == 100 + 800 + 1600 - 20 - 1200);
Assert.IsTrue(manager.GetBalance(walletE.PublicKey) == Program.MinerReward * 4);
Assert.IsTrue(manager.GetBalance(walletF.PublicKey) == 3400);
var lowerNonceBlock = CreateNextBlock(forkBlocks.Last(), new List <Transaction>()
{
CreateTransaction(walletA, walletB, 2000, 2)
});
manager.ProcessBlocks(new List <Block>()
{
lowerNonceBlock
});
Assert.IsTrue(manager.Height == 13);
var higherNonceBlock = CreateNextBlock(forkBlocks.Last(), new List <Transaction>()
{
CreateTransaction(walletA, walletB, 2000, 5)
});
manager.ProcessBlocks(new List <Block>()
{
higherNonceBlock
});
Assert.IsTrue(manager.Height == 13);
var overBalanceBlock = CreateNextBlock(forkBlocks.Last(), new List <Transaction>()
{
CreateTransaction(walletF, walletB, 10000, 0)
});
manager.ProcessBlocks(new List <Block>()
{
overBalanceBlock
});
Assert.IsTrue(manager.Height == 13);
var noBalanceBlock = CreateNextBlock(forkBlocks.Last(), new List <Transaction>()
{
CreateTransaction(new Wallet(), walletB, 10000, 0)
});
manager.ProcessBlocks(new List <Block>()
{
noBalanceBlock
});
Assert.IsTrue(manager.Height == 13);
//persistency check
manager.Dispose();
balanceLedger = new BalanceLedger();
manager = new ChainManager(balanceLedger);
Assert.IsTrue(manager.GetBalance(walletA.PublicKey) == (Program.MinerReward * 4 - 100 - 400 - 1600 - 2400 - 80));
Assert.IsTrue(manager.GetBalance(walletB.PublicKey) == (Program.MinerReward * 4 - 200 - 800 - 3200 - 60 + 400 + 2400));
Assert.IsTrue(manager.GetBalance(walletC.PublicKey) == 1200);
Assert.IsTrue(manager.GetBalance(walletD.PublicKey) == 100 + 800 + 1600 - 20 - 1200);
Assert.IsTrue(manager.GetBalance(walletE.PublicKey) == Program.MinerReward * 4);
Assert.IsTrue(manager.GetBalance(walletF.PublicKey) == 3400);
//miner test
var txPool = new TransactionPool(balanceLedger);
Program.Settings.minerAddr = HexConverter.ToPrefixString(walletM.PublicKey);
var miner = new Miner(balanceLedger, txPool, manager);
for (int i = 0; i < 187; i++)
{
miner.UpdateParameters();
while (miner.MineRound().Result == null)
{
;
}
}
miner.UpdateParameters();
var ret = miner.MineRound().Result;
Assert.IsTrue(manager.Height == 201);
//tx pool test
txPool.AddTransactions(new List <Transaction>()
{
CreateTransaction(walletA, walletF, 5000, manager.GetTransactionCount(walletA.PublicKey)),
CreateTransaction(walletA, walletB, 5000, 5),
CreateTransaction(walletA, walletB, 5000, 8)
});
var mineableTxs = txPool.GetMineableTransactions();
}
public void Initialize(BuildingManager buildingManager, ChainManager chainManager)
{
BuildingManager = buildingManager;
ChainManager = chainManager;
}
void Start()
{
leftTouchPad.SetActive(false);
rightTouchPad.SetActive(false);
chainManager = this.GetComponent <ChainManager>();
}
public void TestChainManager()
{
List<int> lst = new List<int>();
RecorderTester trr = new RecorderTester(lst);
ChainManager.IniParams p = new ChainManager.IniParams();
p.RecordCollection.Add(trr);
ChainManager cm = new ChainManager(p);
// Start End Test
cm.StartRecord();
trr.Add(1);
trr.Add(2);
cm.EndRecord();
List<int> result1 = new List<int> { 1, 2 };
if (result1.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
cm.StartRecord();
trr.Add(3);
trr.Add(4);
cm.EndRecord();
List<int> result2 = new List<int> { 1, 2, 3, 4 };
if (result2.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
// Undo Test
cm.Undo();
if (result1.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
// Redo Test
cm.Redo();
if (result2.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
// Cut Test
cm.StartRecord();
trr.Add(3);
trr.Add(4);
cm.CutRecord();
if (result2.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
// Rollback Test
cm.Rollback();
if (result1.SequenceEqual(lst) == false)
{
throw new NotImplementedException();
}
}
