public static Block GenesisBlock()
{
using (BlockchainDatabase db = BlockchainDatabase.Create())
{
Block genesisBlock = db.Blocks.FindOne(y => y.PreviousBlockHash == ChainParams.EmptyBlockHash);
if (genesisBlock != null)
{
return(genesisBlock);
}
genesisBlock = new Block
{
Date = DateTime.ParseExact("11/01/2018", "dd/MM/yyyy", CultureInfo.InvariantCulture),
Nonce = 4432,
DifficultyMask = ChainParams.CalculateDifficultyMask(null),
PreviousBlockHash = ChainParams.EmptyBlockHash
};
genesisBlock.Transactions.Add(new Transaction
{
Outputs = new List <TransactionOutput>
{
new TransactionOutput {
To = Globals.Keys.GenesisPublicKey, Amount = (decimal)(ChainParams.MaxSupply * ChainParams.PreMinePercentage)
}
}
});
db.Blocks.Insert(genesisBlock);
return(genesisBlock);
}
}
public static byte[] ToCommand <T>(T msg, ChainParams cp) where T : ICommand, IStreamable
{
if (msg != null)
{
using (var ms = new MemoryStream())
{
var mp = msg.ToArray();
var header = new MessageHeader();
header.Magic = cp.NetMagic;
header.Command = msg.Command;
header.PayloadSize = (uint)mp.Length;
//create the checksum of the payload
var h2 = mp.SHA256d();
header.Checksum = BitConverter.ToUInt32(new byte[] { h2[0], h2[1], h2[2], h2[3] }, 0);
var hp = header.ToArray();
ms.Write(hp, 0, hp.Length);
ms.Write(mp, 0, mp.Length);
return(ms.ToArray());
}
}
else
{
return(null);
}
}
public static Memory <byte> ToCommand <T>(T msg, ChainParams cp) where T : ICommand, IStreamable
{
if (msg != null)
{
var header = new MessageHeader();
header.Magic = cp.NetMagic;
header.Command = msg.Command;
header.PayloadSize = (uint)msg.Size;
var total_size = msg.Size + header.Size;
var packed_msg_owner = MemoryPool <byte> .Shared.Rent(total_size);
var packed_msg = packed_msg_owner.Memory;
var body_slice = packed_msg.Span.Slice(header.Size);
msg.WriteToPayload(body_slice);
//create the checksum of the payload
var body_hash = body_slice.Slice(0, msg.Size).SHA256d();
header.Checksum = BitConverter.ToUInt32(new byte[] { body_hash[0], body_hash[1], body_hash[2], body_hash[3] });
header.WriteToPayload(packed_msg.Span);
return(packed_msg.Slice(0, total_size));
}
else
{
return(Memory <byte> .Empty);
}
}
public EthChainParams(ChainParams chainParams)
{
this.CopyFrom(chainParams);
if (!chainParams.Capabilities.HasFlag(CapablityFlags.EthereumProtocol))
{
throw new ArgumentException("ChainParams does not support Ethereum.");
}
}
public BitcoinNode(ChainParams cp, IPEndPoint ip = null)
{
ChainParams = cp;
if (ip == null)
{
ip = new IPEndPoint(IPAddress.Any, 8333);
}
Cts = new CancellationTokenSource();
Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Sock.Bind(ip);
}
public Ethereum_UnitTest()
{
var lParms = new ChainParams();
lParms.Capabilities = CapablityFlags.EthereumProtocol;
lParms.NetworkName = "Ethereum";
FEthChainParams = new EthChainParams(lParms);
EthereumCurrencyAdvocacy.Register();
//
// TODO: Add constructor logic here
//
}
/// <summary>
/// Adds a new peer to the node, all exceptions are thrown back from connection errors.
/// </summary>
/// <param name="ip"></param>
/// <param name="cp"></param>
/// <returns></returns>
/// <exception cref="SocketException"></exception>
public async Task AddPeer(IPEndPoint ip, ChainParams cp = null)
{
var id = Guid.NewGuid();
var np = new T();
np.OnStop += Node_OnStop;
var nc = new BitcoinPeer(cp ?? ChainParams);
await nc.ConnectAsync(ip);
np.Init(this, nc, id);
await np.SendVersion();
if (Peers.TryAdd(id, np))
{
OnLog?.Invoke($"New peer added: {np.RemoteEndpoint}!");
}
}
public static Block GenerateBlock(PublicKey minedBy)
{
Block block = GenerateBlock();
block.Transactions.Add(new Transaction
{
Outputs = new List <TransactionOutput>
{
new TransactionOutput
{
Amount = ChainParams.CalculateBlockReward(block),
To = minedBy
}
}
});
return(block);
}
public static Block GenerateBlock()
{
using (BlockchainDatabase db = BlockchainDatabase.Create())
{
uint lastBlockIndex = (uint)db.Blocks.Max(y => y.BlockIndex).AsInt32;
Block lastBlock = db.Blocks.FindOne(y => y.BlockIndex == lastBlockIndex);
Block newBlock = new Block
{
PreviousBlockHash = lastBlock.Hash,
Date = DateTime.Now,
DifficultyMask = ChainParams.CalculateDifficultyMask(lastBlock),
BlockIndex = lastBlockIndex + 1
};
return(newBlock);
}
}
public TestBlocks(Block genesisBlock = null)
{
// create the key pair that block rewards will be sent to
var keyPair = txManager.CreateKeyPair();
coinbasePrivateKey = keyPair.Item1;
coinbasePublicKey = keyPair.Item2;
// create and mine the genesis block
genesisBlock = genesisBlock ?? MineEmptyBlock(UInt256.Zero);
// initialize unit test rules
rules = new UnitTestRules()
{
// disable execution of rules validation
ValidateTransactionAction = (_, __) => { },
ValidationTransactionScriptAction = (_, __, ___, ____, _____) => { }
};
ChainParams.SetGenesisBlock(genesisBlock);
blocks.Add(genesisBlock);
chain.AddBlock(ChainParams.GenesisChainedHeader);
}
private object InternalConvert(JsonSerializer aSerializer, JObject aItem, Type aType)
{
object lResult;
if (aType.IsAssignableFrom(typeof(ICurrencyItem)))
{
lResult = new CurrencyItem
{
Id = aItem["Id"].Value <long>(),
Name = aItem["Name"].Value <string>(),
Ticker = aItem["Ticker"].Value <string>(),
Precision = aItem["Precision"].Value <ushort>(),
LiveDate = aItem["LiveDate"].Value <DateTime>(),
MinConfirmations = aItem["MinConfirmations"].Value <int>(),
Icon = GetIcon(aItem, aSerializer),
FeePerKb = aItem["FeePerKb"].Value <long>(),
ChainParamaters = aItem["ChainParamaters"].ToObject <ChainParams>(aSerializer),
CurrentStatus = (CurrencyStatus)aItem["CurrentStatus"].Value <int>()
}
}
;
else if (aType.Equals(typeof(ChainParams)))
{
lResult = new ChainParams()
{
NetworkName = aItem["NetworkName"].Value <string>(),
Network = (ChainParams.NetworkType)aItem["Network"].Value <int>(),
PublicKeyAddress = aItem["PublicKeyAddress"].ToObject <byte[]>(aSerializer),
ScriptAddress = aItem["ScriptAddress"].ToObject <byte[]>(aSerializer),
SecretKey = aItem["SecretKey"].ToObject <byte[]>(aSerializer),
ExtPublicKey = aItem["ExtPublicKey"].ToObject <byte[]>(aSerializer),
ExtSecretKey = aItem["ExtSecretKey"].ToObject <byte[]>(aSerializer),
ForkFromId = aItem["ForkFromId"].Value <long>(),
EncryptedSecretKeyNoEc = aItem["EncryptedSecretKeyNoEc"].ToObject <byte[]>(aSerializer),
EncryptedSecretKeyEc = aItem["EncryptedSecretKeyEc"].ToObject <byte[]>(aSerializer),
PasspraseCode = aItem["PasspraseCode"].ToObject <byte[]>(aSerializer),
ConfirmationCode = aItem["ConfirmationCode"].ToObject <byte[]>(aSerializer),
StealthAddress = aItem["StealthAddress"].ToObject <byte[]>(aSerializer),
AssetId = aItem["AssetId"].ToObject <byte[]>(aSerializer),
Capabilities = (CapablityFlags)aItem["Capabilities"].Value <int>(),
ColoredAddress = aItem["ColoredAddress"].ToObject <byte[]>(aSerializer),
Encoder = aItem["Encoder"].Value <string>(),
Version = aItem["Version"].Value <long>()
}
}
;
else if (aType.Equals(typeof(CurrencyStatusItem)))
{
lResult = new CurrencyStatusItem(aItem["StatusId"].Value <long>(),
aItem["CurrencyId"].Value <long>(),
aItem["StatusTime"].Value <DateTime>(),
(CurrencyStatus)Enum.Parse(typeof(CurrencyStatus),
aItem["Status"].Value <string>()),
aItem["ExtendedInfo"].Value <string>(),
aItem["BlockHeight"].Value <long>());
}
else if (aType.Equals(typeof(CurrencyAccount)))
{
lResult = new CurrencyAccount(aItem["Id"].Value <long>(), aItem["CurrencyId"].Value <long>(), aItem["Address"].Value <string>());
}
else if (aType.Equals(typeof(TransactionUnit)))
{
lResult = new TransactionUnit(aItem["Id"].Value <long>(), aItem["Amount"].Value <long>(), aItem["Address"].Value <string>(), aItem.TryGetValue("Index", out JToken lIndexObject) ? lIndexObject.Value <int>() : -1, aScript: aItem["Script"].Value <string>());
}
else if (aType.Equals(typeof(TransactionRecord)))
{
TransactionRecord lTxRcd = new TransactionRecord(
aItem["TransactionRecordId"].Value <long>(),
aItem["CurrencyId"].Value <long>(),
aItem["TxId"].Value <string>(),
aItem["TxDate"].Value <DateTime>(),
aItem["Block"].Value <long>(),
aItem["Valid"].Value <bool>()
);
lTxRcd.AddInput(aItem["Inputs"].ToObject <TransactionUnit[]>(aSerializer));
lTxRcd.AddOutput(aItem["Outputs"].ToObject <TransactionUnit[]>(aSerializer));
lTxRcd.TxFee = aItem["TxFee"].Value <long>();
lResult = lTxRcd;
}
else if (aType.Equals(typeof(CurrencyTransaction)))
{
lResult = new CurrencyTransaction(aItem["Inputs"].ToObject <TransactionUnit[]>(aSerializer), aItem["Outputs"].ToObject <TransactionUnit[]>(aSerializer), aItem["TxFee"].Value <long>(), aItem["CurrencyId"].Value <long>());
}
else if (aType.Equals(typeof(UserStatus)))
{
lResult = new UserStatus(aItem["Active"].Value <bool>(), aItem["ExtendedInfo"].Value <string>(), aItem["StatusDate"].Value <DateTime>());
}
else
{
lResult = aItem.ToObject(aType, aSerializer);
}
return(lResult);
}
public ICryptoCurrencyAdvocacy GetCurrencyAdvocacy(long aCurrencyId, ChainParams aChainParams)
{
ICryptoCurrencyAdvocacy lAdvocacy = CurrencyControl.GetClientCurrencyAdvocacy(aCurrencyId, aChainParams, GetStringRootSeed);
return(lAdvocacy);
}
private static ICryptoCurrencyAdvocacy EthGetCurrencyAdvocacy(long aCurrencyId, ChainParams aChainParams, Func <string> aGetRootSeed)
{
if (aChainParams.Capabilities.HasFlag(CapablityFlags.EthereumProtocol))
{
return(new EthereumCurrencyAdvocacy(aCurrencyId, new EthChainParams(aChainParams), aGetRootSeed));
}
else
{
return(null);
}
}
private static async Task RunNode()
{
try
{
BlockChain.Init();
var cp_btc = new ChainParams();
Node = new BitcoinNode <BitcoinNodePeer>(cp_btc, new IPEndPoint(IPAddress.Any, 8336));
Node.OnLog += Node_OnLog;
Node.Start();
//var ct = node.AddPeer(new IPEndPoint(IPAddress.Parse("192.168.254.6"), 8333));
//var ct2 = node.AddPeer(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8333));
//if no peers, add seeds
if (BlockChain.Peers.Count == 0)
{
Console.WriteLine("No peers found, adding seed nodes..");
foreach (var seed in DNSSeeds)
{
try
{
var ips = await Dns.GetHostAddressesAsync(seed);
foreach (var ip in ips)
{
var ep = new IPEndPoint(ip, 8333);
BlockChain.Peers.Add(ep.AsHash(), new PeerInfo()
{
Ip = ep,
LastSeen = DateTime.Now,
LastVersion = new bitcoin_lib.P2P.Version()
});
}
}
catch (Exception ex)
{
Console.WriteLine($"No ips found for seed: {seed} ({ex.Message})");
}
}
}
//connect to last 8 peers
await TryAddLastPeers();
bool exit = false;
Console.CancelKeyPress += (s, e) =>
{
Console.WriteLine($"Shutting down..");
exit = true;
//doesnt work in .net core it seems..
//https://github.com/dotnet/coreclr/issues/8565
};
while (!exit)
{
//ping the peers every 60s
if ((DateTime.Now - LastPingSent).TotalSeconds >= 60)
{
//disconnect a high ping node
BitcoinNodePeer hpn = Node.EnumeratePeers().Where(a => a.LastPing != TimeSpan.Zero).OrderByDescending(a => a.LastPing.TotalMilliseconds).FirstOrDefault();
if (hpn != default)
{
hpn.Disconnect();
}
var pt = new List <Task>();
foreach (var n in Node.EnumeratePeers())
{
pt.Add(n.StartPing());
}
await Task.WhenAll(pt);
LastPingSent = DateTime.Now;
}
//try to get 8 peers
if (Node.EnumeratePeers().Count() < 8)
{
//ask for more peers if we dont have enough
if (BlockChain.Peers.Count < 100)
{
Console.WriteLine($"Not enough known peers, asking for more..");
foreach (var n in Node.EnumeratePeers())
{
var addr = new GetAddr();
await n.WriteMessage(addr);
}
//wait 2s for nodes to reply
await Task.Delay(2000);
}
await TryAddLastPeers();
}
await Task.Delay(100);
}
await ShutdownNode();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
