public static KeyValuePair <TransactionInNoneCoinbase, int> Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var outpoint = Outpoint.Deserialize(payload.ToArray());
int startIndex = Outpoint.SIZE;
var compactSize = CompactSize.Deserialize(payload.Skip(startIndex).ToArray());
startIndex += compactSize.Value;
IEnumerable <byte> signatureScripts = new List <byte>();
if (compactSize.Key.Size > 0)
{
signatureScripts = payload.Skip(startIndex).Take((int)compactSize.Key.Size);
startIndex += (int)compactSize.Key.Size;
}
var sequence = BitConverter.ToUInt32(payload.Skip(startIndex).Take(4).ToArray(), 0);
startIndex += 4;
return(new KeyValuePair <TransactionInNoneCoinbase, int>(new TransactionInNoneCoinbase(outpoint, signatureScripts, sequence), startIndex));
}
public static VersionMessage Deserialize(byte[] payload, Networks network)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var transmittingService = (ServiceFlags)BitConverter.ToUInt64(payload.Skip(4).Take(8).ToArray(), 0);
var receivingService = (ServiceFlags)BitConverter.ToUInt64(payload.Skip(20).Take(8).ToArray(), 0);
var receivingIpv6Addr = payload.Skip(28).Take(16);
var receivingPort = BitConverter.ToUInt16(payload.Skip(44).Take(2).ToArray(), 0);
var transmittingIpv6Addr = payload.Skip(54).Take(16);
var transmittingPort = BitConverter.ToUInt16(payload.Skip(70).Take(2).ToArray(), 0);
var nonce = BitConverter.ToUInt64(payload.Skip(72).Take(8).ToArray(), 0);
var compactSize = CompactSize.Deserialize(payload.Skip(80).ToArray());
string userAgent = null;
int startIndex = 80 + compactSize.Value;
if (compactSize.Key.Size > 0)
{
userAgent = System.Text.Encoding.UTF8.GetString(payload.Skip(startIndex).Take(startIndex + (int)compactSize.Key.Size).ToArray());
startIndex += (int)compactSize.Key.Size;
}
var startHeight = BitConverter.ToInt32(payload.Skip(startIndex).Take(4).ToArray(), 0);
var relay = BitConverter.ToBoolean(payload.Skip(startIndex).Take(1).ToArray(), 0);
return(new VersionMessage(new IpAddress(DateTime.UtcNow, transmittingService, transmittingIpv6Addr.ToArray(), transmittingPort),
new IpAddress(DateTime.UtcNow, receivingService, receivingIpv6Addr.ToArray(), receivingPort),
nonce, userAgent, startHeight, relay, network));
}
public static Block Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var header = DeserializeBlockHeader(payload);
int currentIndex = 80;
var transactionLst = new List <BaseTransaction>();
var kvp = CompactSize.Deserialize(payload.Skip(80).ToArray());
currentIndex += kvp.Value;
if (kvp.Key.Size > 0)
{
for (var i = 0; i < (int)kvp.Key.Size; i++)
{
var skvp = BaseTransaction.Deserialize(payload.Skip(currentIndex));
transactionLst.Add(skvp.Key);
currentIndex += skvp.Value;
}
}
var result = new Block(header.PreviousBlockHeader, header.NBits, header.Nonce);
result.BlockHeader = header;
result.Transactions = transactionLst;
return(result);
}
public override IEnumerable <byte> Serialize()
{
var result = new List <byte>();
result.AddRange(BitConverter.GetBytes(Version));
result.Add((byte)TransactionCategories.SmartContract);
var fromCompactSize = new CompactSize();
var toCompactSize = new CompactSize();
var dataCompactSize = new CompactSize();
fromCompactSize.Size = (ulong)From.Count();
toCompactSize.Size = To == null ? 0 : (ulong)To.Count();
dataCompactSize.Size = Data == null ? 0 : (ulong)Data.Count();
result.AddRange(fromCompactSize.Serialize()); // FROM.
result.AddRange(From);
result.AddRange(toCompactSize.Serialize()); // TO
result.AddRange(To);
result.AddRange(dataCompactSize.Serialize()); // DATA
result.AddRange(Data);
result.AddRange(BitConverter.GetBytes(Gas));
result.AddRange(BitConverter.GetBytes(GasPrice));
result.AddRange(BitConverter.GetBytes(Value));
result.AddRange(BitConverter.GetBytes(Nonce));
result.AddRange(BitConverter.GetBytes(LockTime));
return(result);
}
public override IEnumerable <byte> Serialize()
{
// https://bitcoin.org/en/developer-reference#raw-transaction-format
var result = new List <byte>();
result.AddRange(BitConverter.GetBytes(Version));
result.Add((byte)TransactionCategories.Monetary);
result.Add((byte)TransactionType);
var inputCompactSize = new CompactSize();
inputCompactSize.Size = (ulong)TransactionIn.Count();
result.AddRange(inputCompactSize.Serialize());
foreach (var input in TransactionIn)
{
result.AddRange(input.Serialize());
}
var outputCompactSize = new CompactSize();
outputCompactSize.Size = (ulong)TransactionOut.Count();
result.AddRange(outputCompactSize.Serialize());
foreach (var output in TransactionOut)
{
result.AddRange(output.Serialize());
}
result.AddRange(BitConverter.GetBytes(LockTime));
return(result);
}
public IEnumerable <byte> Serialize()
{
var result = new List <byte>();
var dataPayload = Data;
var authorPayload = System.Text.Encoding.UTF8.GetBytes(Author);
var namePayload = System.Text.Encoding.UTF8.GetBytes(Name);
var parametersPayload = System.Text.Encoding.UTF8.GetBytes(string.Join(",", Parameters));
var compactSizeScript = new CompactSize();
var compactSizeData = new CompactSize();
var compactSizeAutor = new CompactSize();
var compactSizeName = new CompactSize();
var compactSizeParameters = new CompactSize();
compactSizeData.Size = (ulong)dataPayload.Count();
compactSizeAutor.Size = (ulong)authorPayload.Count();
compactSizeName.Size = (ulong)namePayload.Count();
compactSizeParameters.Size = (ulong)parametersPayload.Count();
result.AddRange(compactSizeData.Serialize()); // DATA.
result.AddRange(dataPayload);
result.AddRange(compactSizeAutor.Serialize()); // AUTHOR.
result.AddRange(authorPayload);
result.AddRange(compactSizeName.Serialize()); // NAME.
result.AddRange(namePayload);
result.AddRange(compactSizeParameters.Serialize()); // PARAMETERS.
result.AddRange(parametersPayload);
return(result);
}
public IEnumerable <byte> Serialize()
{
var result = new List <byte>();
var scriptPayload = Script.Serialize();
var compactSize = new CompactSize();
compactSize.Size = (ulong)scriptPayload.Count();
result.AddRange(BitConverter.GetBytes(Value));
result.AddRange(compactSize.Serialize());
result.AddRange(scriptPayload);
return(result);
}
protected override byte[] GetSerializedContent()
{
var result = new List <byte>();
result.AddRange(CompactSize.Serialize());
foreach (var ipAdr in IpAddresses)
{
result.AddRange(ipAdr.Serialize());
}
return(result.ToArray());
}
public static KeyValuePair <BaseTransaction, int> Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
SmartContractTransaction result = new SmartContractTransaction();
int currentStartIndex = 0;
result.Version = BitConverter.ToUInt32(payload.Take(4).ToArray(), 0);
result.Category = (TransactionCategories)payload.ElementAt(4);
currentStartIndex = 5;
var fromCompactSize = CompactSize.Deserialize(payload.Skip(currentStartIndex).ToArray()); // FROM
currentStartIndex += fromCompactSize.Value;
if (fromCompactSize.Key.Size > 0)
{
result.From = payload.Skip(currentStartIndex).Take((int)fromCompactSize.Key.Size);
currentStartIndex += (int)fromCompactSize.Key.Size;
}
var toCompactSize = CompactSize.Deserialize(payload.Skip(currentStartIndex).ToArray()); // TO
currentStartIndex += toCompactSize.Value;
if (toCompactSize.Key.Size > 0)
{
result.To = payload.Skip(currentStartIndex).Take((int)toCompactSize.Key.Size);
currentStartIndex += (int)toCompactSize.Key.Size;
}
var dataCompactSize = CompactSize.Deserialize(payload.Skip(currentStartIndex).ToArray()); // DATA
currentStartIndex += dataCompactSize.Value;
if (dataCompactSize.Key.Size > 0)
{
result.Data = payload.Skip(currentStartIndex).Take((int)dataCompactSize.Key.Size);
currentStartIndex += (int)dataCompactSize.Key.Size;
}
result.Gas = BitConverter.ToDouble(payload.Skip(currentStartIndex).Take(8).ToArray(), 0);
currentStartIndex += 8;
result.GasPrice = BitConverter.ToDouble(payload.Skip(currentStartIndex).Take(8).ToArray(), 0);
currentStartIndex += 8;
result.Value = BitConverter.ToDouble(payload.Skip(currentStartIndex).Take(8).ToArray(), 0);
currentStartIndex += 8;
result.Nonce = BitConverter.ToInt32(payload.Skip(currentStartIndex).Take(4).ToArray(), 0);
currentStartIndex += 4;
result.LockTime = BitConverter.ToUInt32(payload.Skip(currentStartIndex).Take(4).ToArray(), 0);
currentStartIndex += 4;
return(new KeyValuePair <BaseTransaction, int>(result, currentStartIndex));
}
public static KeyValuePair <BaseTransaction, int> Deserialize(IEnumerable <byte> payload)
{
int currentStartIndex = 0;
var version = BitConverter.ToUInt32(payload.Take(4).ToArray(), 0);
var category = (TransactionCategories)payload.ElementAt(4);
var transactionType = (TransactionTypes)payload.ElementAt(5);
BcBaseTransaction result = null;
switch (transactionType)
{
case TransactionTypes.Coinbase:
result = new CoinbaseTransaction();
break;
case TransactionTypes.NoneCoinbase:
result = new NoneCoinbaseTransaction();
break;
}
result.Version = version;
result.Category = category;
currentStartIndex = 6;
var transactionInCompactSize = CompactSize.Deserialize(payload.Skip(currentStartIndex).ToArray());
currentStartIndex += transactionInCompactSize.Value;
if (transactionInCompactSize.Key.Size > 0)
{
var kvp = result.DeserializeInputs(payload.Skip(currentStartIndex), (int)transactionInCompactSize.Key.Size);
result.TransactionIn = kvp.Key;
currentStartIndex += kvp.Value;
}
var transactionOutputCompactSize = CompactSize.Deserialize(payload.Skip(currentStartIndex).ToArray());
currentStartIndex += transactionOutputCompactSize.Value;
if (transactionOutputCompactSize.Key.Size > 0)
{
for (var i = 0; i < (int)transactionOutputCompactSize.Key.Size; i++)
{
var kvp = result.DeserializeOutput(payload.Skip(currentStartIndex).ToArray());
result.TransactionOut.Add(kvp.Key);
currentStartIndex += kvp.Value;
}
}
result.LockTime = BitConverter.ToUInt32(payload.Skip(currentStartIndex).Take(4).ToArray(), 0);
currentStartIndex += 4;
return(new KeyValuePair <BaseTransaction, int>(result, currentStartIndex));
}
protected override byte[] GetSerializedContent()
{
var size = Inventories.Count();
var compactSize = new CompactSize();
compactSize.Size = (ulong)size;
var result = new List <byte>();
result.AddRange(compactSize.Serialize());
foreach (var inventory in Inventories)
{
result.AddRange(inventory.Serialize());
}
return(result.ToArray());
}
public static Script Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
return(null);
}
var scriptRecords = new List <ScriptRecord>();
var opValues = Enum.GetValues(typeof(OpCodes)).Cast <byte>();
int indice = 0;
int nextIndice = 0;
foreach (var b in payload)
{
if (!opValues.Contains(b) || indice < nextIndice)
{
indice++;
continue;
}
var opCode = (OpCodes)b;
if (opCode == OpCodes.OP_DATA)
{
indice++;
var compactSize = CompactSize.Deserialize(payload.Skip(indice).ToArray());
var newIndice = indice + compactSize.Value;
var dataSize = (int)compactSize.Key.Size;
scriptRecords.Add(new ScriptRecord(payload.Skip(newIndice).Take(dataSize).ToList()));
nextIndice = newIndice + dataSize;
continue;
}
scriptRecords.Add(new ScriptRecord(opCode));
indice++;
}
var opCodes = scriptRecords.Where(s => s.Type == ScriptRecordType.Operation).Select(s => s.OpCode.Value);
var result = new Script(scriptRecords);
if (opCodes.SequenceEqual(_p2pkhOperations))
{
result.Type = ScriptTypes.P2PKH;
}
return(result);
}
public override byte[] Serialize()
{
var result = new List <byte>();
var hashPayload = new byte[32];
Array.Clear(hashPayload, 0, 32);
var compactSize = new CompactSize();
compactSize.Size = (ulong)CoinBaseScript.Count();
result.AddRange(hashPayload);
result.AddRange(BitConverter.GetBytes(DEFAULT_INDEX));
result.AddRange(compactSize.Serialize());
result.AddRange(BitConverter.GetBytes(Height));
result.AddRange(CoinBaseScript);
result.AddRange(BitConverter.GetBytes(Sequence));
return(result.ToArray());
}
protected override byte[] GetSerializedContent()
{
var result = new List <byte>();
var versionPayload = BitConverter.GetBytes(Constants.SupportedProtocolVersion);
var compactSize = new CompactSize();
compactSize.Size = (ulong)BlockHashes.Count();
result.AddRange(versionPayload);
result.AddRange(compactSize.Serialize());
foreach (var blockHash in BlockHashes)
{
result.AddRange(blockHash);
}
return(result.ToArray());
}
public static KeyValuePair <TransactionOutSmartContract, int> Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
int startIndex = 0;
var compactSizeScript = CompactSize.Deserialize(payload.Skip(startIndex).ToArray()); // SCRIPT.
startIndex += compactSizeScript.Value;
var script = Script.Deserialize(payload.Skip(startIndex).Take((int)compactSizeScript.Key.Size));
startIndex += (int)compactSizeScript.Key.Size;
var compactSizeData = CompactSize.Deserialize(payload.Skip(startIndex).ToArray()); // AUTHOR.
startIndex += compactSizeData.Value;
var data = payload.Skip(startIndex).Take((int)compactSizeData.Key.Size);
startIndex += (int)compactSizeData.Key.Size;
var compactSizeAuthor = CompactSize.Deserialize(payload.Skip(startIndex).ToArray()); // AUTHOR.
startIndex += compactSizeAuthor.Value;
var author = System.Text.Encoding.UTF8.GetString(payload.Skip(startIndex).Take((int)compactSizeAuthor.Key.Size).ToArray());
startIndex += (int)compactSizeAuthor.Key.Size;
var compactSizeName = CompactSize.Deserialize(payload.Skip(startIndex).ToArray()); // AUTHOR.
startIndex += compactSizeName.Value;
var name = System.Text.Encoding.UTF8.GetString(payload.Skip(startIndex).Take((int)compactSizeName.Key.Size).ToArray());
startIndex += (int)compactSizeName.Key.Size;
var compactSizeParameters = CompactSize.Deserialize(payload.Skip(startIndex).ToArray()); // PARAMETERS.
startIndex += compactSizeParameters.Value;
var parameters = System.Text.Encoding.UTF8.GetString(payload.Skip(startIndex).Take((int)compactSizeParameters.Key.Size).ToArray()).Split(',');
startIndex += (int)compactSizeParameters.Key.Size;
return(new KeyValuePair <TransactionOutSmartContract, int>(new TransactionOutSmartContract(script, data, author, name, parameters), startIndex));
}
public byte[] Serialize()
{
var result = new List <byte>();
var rawTransactions = new List <byte>();
var compactSize = new CompactSize
{
Size = (ulong)Transactions.Count()
};
foreach (var transaction in Transactions)
{
rawTransactions.AddRange(transaction.Serialize());
}
result.AddRange(SerializeHeader());
result.AddRange(compactSize.Serialize());
result.AddRange(rawTransactions);
return(result.ToArray());
}
public static KeyValuePair <TransactionOut, int> Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
int startIndex = 0;
var value = BitConverter.ToInt64(payload.Take(8).ToArray(), 0);
startIndex = 8;
var compactSize = CompactSize.Deserialize(payload.Skip(startIndex).ToArray());
startIndex += compactSize.Value;
var script = Script.Deserialize(payload.Skip(startIndex).Take((int)compactSize.Key.Size));
startIndex += (int)compactSize.Key.Size;
return(new KeyValuePair <TransactionOut, int>(new TransactionOut(value, script), startIndex));
}
public static AddrMessage Deserialize(byte[] payload, Networks network)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var kvp = CompactSize.Deserialize(payload);
var compactSize = kvp.Key;
var contentPayload = payload.Skip(kvp.Value);
var nb = contentPayload.Count() / IpAddress.Size;
var lstAddr = new List <IpAddress>();
for (var i = 0; i < nb; i++)
{
var addrPayload = contentPayload.Skip(i * IpAddress.Size).Take(IpAddress.Size).ToArray();
lstAddr.Add(IpAddress.Deserialize(addrPayload));
}
return(new AddrMessage(compactSize, network, lstAddr));
}
public IEnumerable <byte> Serialize()
{
var result = new List <byte>();
switch (Type)
{
case ScriptRecordType.Operation:
result.AddRange(new byte[] { (byte)OpCode });
break;
case ScriptRecordType.Stack:
result.AddRange(new byte[] { (byte)OpCodes.OP_DATA });
var compactSize = new CompactSize();
compactSize.Size = (ulong)StackRecord.Count();
result.AddRange(compactSize.Serialize());
result.AddRange(StackRecord);
break;
}
return(result);
}
public override byte[] Serialize()
{
var result = new List <byte>();
result.AddRange(Outpoint.Serialize());
var compactSize = new CompactSize();
compactSize.Size = 0;
if (SignatureScript != null)
{
compactSize.Size = (ulong)SignatureScript.Count();
result.AddRange(compactSize.Serialize());
result.AddRange(SignatureScript);
}
else
{
result.AddRange(compactSize.Serialize());
}
result.AddRange(BitConverter.GetBytes(Sequence));
return(result.ToArray());
}
public static GetBlocksMessage Deserialize(byte[] payload, Networks network)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var compactSize = CompactSize.Deserialize(payload.Skip(4).ToArray());
var blockHashes = new List <IEnumerable <byte> >();
if (compactSize.Key.Size > 0)
{
var startIndex = 4 + compactSize.Value;
for (var i = 0; i < (int)compactSize.Key.Size; i++)
{
blockHashes.Add(payload.Skip(startIndex).Take(32));
startIndex += 32;
}
}
return(new GetBlocksMessage(blockHashes, network));
}
public static KeyValuePair <TransactionInCoinbase, int> Deserialize(IEnumerable <byte> payload)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
int startIndex = 36;
var compactSize = CompactSize.Deserialize(payload.Skip(startIndex).ToArray());
startIndex += compactSize.Value;
var height = BitConverter.ToUInt32(payload.Skip(startIndex).Take(4).ToArray(), 0);
startIndex += 4;
var coinBaseScript = payload.Skip(startIndex).Take((int)compactSize.Key.Size).ToArray();
startIndex += (int)compactSize.Key.Size;
var sequence = BitConverter.ToUInt32(payload.Skip(startIndex).Take(4).ToArray(), 0);
startIndex += 4;
return(new KeyValuePair <TransactionInCoinbase, int>(new TransactionInCoinbase(height, coinBaseScript, sequence), startIndex));
}
public static GetDataMessage Deserialize(byte[] payload, Networks network)
{
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var compactSize = CompactSize.Deserialize(payload);
var inventories = new List <Inventory>();
if (compactSize.Key.Size > 0)
{
var content = payload.Skip(compactSize.Value);
var size = (int)compactSize.Key.Size;
for (var i = 0; i < size; i++)
{
var inventoryPayload = content.Skip(i * Inventory.Size).Take(Inventory.Size);
inventories.Add(Inventory.Deserialize(inventoryPayload));
}
}
return(new GetDataMessage(inventories, network));
}
protected override byte[] GetSerializedContent()
{
var result = new List <byte>();
var versionPayload = BitConverter.GetBytes(Constants.SupportedProtocolVersion);
var transmittingServicePayload = BitConverter.GetBytes((UInt64)TransmittingNode.ServiceFlag);
var timeStampPayload = BitConverter.GetBytes(DateTime.UtcNow.ToUnixTime());
var receivingServiceFlagPayload = BitConverter.GetBytes((UInt64)ReceivingNode.ServiceFlag);
var receivingIpV6Payload = ReceivingNode.Ipv6;
var receivingPortPayload = BitConverter.GetBytes(ReceivingNode.Port);
var transmittingIpV6Payload = TransmittingNode.Ipv6;
var transmittingPortPayload = BitConverter.GetBytes(TransmittingNode.Port);
var noncePayload = BitConverter.GetBytes(Nonce);
var userAgentPayload = string.IsNullOrWhiteSpace(UserAgent) ? new byte[0] : System.Text.Encoding.UTF8.GetBytes(UserAgent);
var compactSize = new CompactSize();
compactSize.Size = (ulong)userAgentPayload.Count();
var startHeightPayload = BitConverter.GetBytes(StartHeight);
var relayPayload = BitConverter.GetBytes(Relay);
result.AddRange(versionPayload);
result.AddRange(transmittingServicePayload);
result.AddRange(timeStampPayload);
result.AddRange(receivingServiceFlagPayload);
result.AddRange(receivingIpV6Payload);
result.AddRange(receivingPortPayload);
result.AddRange(transmittingServicePayload);
result.AddRange(transmittingIpV6Payload);
result.AddRange(transmittingPortPayload);
result.AddRange(noncePayload);
result.AddRange(compactSize.Serialize());
result.AddRange(userAgentPayload);
result.AddRange(startHeightPayload);
result.AddRange(relayPayload);
return(result.ToArray());
}
public AddrMessage(CompactSize compactSize, Networks network, List <IpAddress> ipAddresses) : base(network)
{
CompactSize = compactSize;
IpAddresses = ipAddresses;
}
public AddrMessage(CompactSize compactSize, Networks network) : base(network)
{
CompactSize = compactSize;
IpAddresses = new List <IpAddress>();
}
