public async Task CanWriteReadAndDeleteContainer()
{
var sut = CreateAzureBlobRdDataStorage(out var metadataStorage);
var dataType = nameof(DataBlob);
var id = "BlobStorageTestBlob";
var dataBlob = new DataBlob(id, new byte[] { 0x42, 0x43, 0x44 }, "myFile.bin");
var payload = DataEncoder.Encode(JsonConvert.SerializeObject(dataBlob));
var submitter = "jdoe";
var utcNow = DateTime.UtcNow;
var container = new GenericDataContainer(id, submitter, utcNow, submitter, utcNow, ApiVersion.Current, payload);
if (await sut.ExistsAsync(dataType, id))
{
await sut.DeleteDataContainerAsync(dataType, id);
}
IdReservationResult idReservation = null;
Assert.That(async() => idReservation = await sut.ReserveIdAsync(dataType, id, submitter), Throws.Nothing);
Assert.That(idReservation.IsReserved, Is.True);
Assert.That(() => sut.StoreAsync(dataType, container, true), Throws.Nothing);
metadataStorage.Setup(x => x.GetFromIdAsync(dataType, id)).Returns(Task.FromResult(container));
Assert.That(await sut.ExistsAsync(dataType, id), Is.True);
GenericDataContainer retreivedContainer = null;
Assert.That(async() => retreivedContainer = await sut.GetFromIdAsync(dataType, id), Throws.Nothing);
Assert.That(retreivedContainer, Is.Not.Null);
Assert.That(async() => await sut.DeleteDataContainerAsync(dataType, id), Throws.Nothing);
metadataStorage.Setup(x => x.GetFromIdAsync(dataType, id)).Returns(Task.FromResult(default(GenericDataContainer)));
Assert.That(await sut.ExistsAsync(dataType, id), Is.False);
}
public void TestWireDecodeTransaction()
{
var actual = DataDecoder.DecodeTransaction(null, TRANSACTION_1_BYTES.ToArray());
var actualBytes = DataEncoder.EncodeTransaction(actual).TxBytes;
CollectionAssert.AreEqual(TRANSACTION_1_BYTES.ToList(), actualBytes.ToList());
}
/// <summary>
/// 压缩Json并保存
/// </summary>
/// <param name="FilePath"></param>
/// <param name="JsonStr"></param>
/// <returns></returns>
private bool ZipStringAndSave(string FilePath, string JsonStr)
{
try
{
if (File.Exists(FilePath))
{
File.Delete(FilePath);
}
FileStream _FileStream = new FileStream(FilePath, FileMode.CreateNew);
try
{
if (!string.IsNullOrEmpty(JsonStr) && JsonStr.Length > 0)
{
string tempEncoder = DataEncoder.GZipCompressString(JsonStr);
byte[] temp = System.Text.Encoding.UTF8.GetBytes(tempEncoder);
_FileStream.Write(temp, 0, temp.Length);
_FileStream.Flush();
_FileStream.Close();
_FileStream = null;
}
}
catch (Exception exf)
{
_FileStream.Close();
_FileStream = null;
throw exf;
}
}
catch (Exception ex)
{
throw ex;
}
return(false);
}
public IEnumerable <KeyValuePair <TxOutputKey, TxOutput> > UnspentOutputs()
{
Api.JetBeginTransaction2(this.jetSession, BeginTransactionGrbit.ReadOnly);
try
{
//Api.JetSetCurrentIndex(this.jetSession, this.unspentTxOutputsTableId, "IX_TxOutputKey");
Api.MoveBeforeFirst(this.jetSession, this.unspentTxOutputsTableId);
while (Api.TryMoveNext(this.jetSession, this.unspentTxOutputsTableId))
{
var txOutputKey = DataEncoder.DecodeTxOutputKey(Api.RetrieveColumn(this.jetSession, this.unspentTxOutputsTableId, this.txOutputKeyColumnId));
var txOutputBytes = Api.RetrieveColumn(this.jetSession, this.unspentTxOutputsTableId, this.txOutputSmallColumnId);
if (txOutputBytes == null)
{
txOutputBytes = Api.RetrieveColumn(this.jetSession, this.unspentTxOutputsTableId, this.txOutputLargeColumnId);
}
var txOutput = DataEncoder.DecodeTxOutput(txOutputBytes);
yield return(new KeyValuePair <TxOutputKey, TxOutput>(txOutputKey, txOutput));
}
}
finally
{
Api.JetCommitTransaction(this.jetSession, CommitTransactionGrbit.LazyFlush);
}
}
public bool TryAddChainedHeader(ChainedHeader chainedHeader)
{
var key = MakeHeaderKey(chainedHeader.Hash);
Slice existingValue;
if (db.TryGet(ReadOptions.Default, key, out existingValue))
{
return(false);
}
var writeBatch = new WriteBatch();
try
{
writeBatch.Put(key, DataEncoder.EncodeChainedHeader(chainedHeader));
writeBatch.Put(MakeTotalWorkKey(chainedHeader.Hash, chainedHeader.TotalWork), new byte[1]);
db.Write(WriteOptions.Default, writeBatch);
}
finally
{
writeBatch.Dispose();
}
return(true);
}
public void RoundtripPreservesData()
{
var sut = new BinaryDataObjectSplitter(nameof(DataBlob.Data));
var id = IdGenerator.FromGuid();
var dataBlob = new DataBlob(id, new byte[] { 0x42, 0x43, 0x44 }, "myFile.bin");
var payload = DataEncoder.Encode(JsonConvert.SerializeObject(dataBlob));
var utcNow = DateTime.UtcNow;
var container = new GenericDataContainer(id, "jdoe", utcNow, "jdoe", utcNow, "1.5.9", payload);
BinaryDataObjectSplitterResult result = null;
Assert.That(() => result = sut.Split(container), Throws.Nothing);
Assert.That(result, Is.Not.Null);
Assert.That(result.BinaryData, Is.EqualTo(dataBlob.Data));
var containerWithoutBinaryData = result.ContainerWithoutBinaryData;
Assert.That(containerWithoutBinaryData.Id, Is.EqualTo(container.Id));
Assert.That(containerWithoutBinaryData.Submitter, Is.EqualTo(container.Submitter));
Assert.That(containerWithoutBinaryData.SubmissionTimeUtc, Is.EqualTo(container.SubmissionTimeUtc));
Assert.That(containerWithoutBinaryData.ApiVersion, Is.EqualTo(container.ApiVersion));
Assert.That(containerWithoutBinaryData.Data, Is.Not.Null);
Assert.That(containerWithoutBinaryData.Data.GetValue(nameof(DataBlob.Data)), Is.EqualTo(BsonString.Empty));
var reconstructedContainer = sut.Reassemble(containerWithoutBinaryData, result.BinaryData);
Assert.That(reconstructedContainer.Id, Is.EqualTo(container.Id));
Assert.That(reconstructedContainer.Submitter, Is.EqualTo(container.Submitter));
Assert.That(reconstructedContainer.SubmissionTimeUtc, Is.EqualTo(container.SubmissionTimeUtc));
Assert.That(reconstructedContainer.ApiVersion, Is.EqualTo(container.ApiVersion));
Assert.That(reconstructedContainer.Data, Is.Not.Null);
var reconstructedDataBlob = JsonConvert.DeserializeObject <DataBlob>(reconstructedContainer.Data.ToJson());
Assert.That(reconstructedDataBlob.Id, Is.EqualTo(dataBlob.Id));
Assert.That(reconstructedDataBlob.Filename, Is.EqualTo(dataBlob.Filename));
Assert.That(reconstructedDataBlob.Data, Is.EqualTo(dataBlob.Data));
}
public bool TryRemoveUnspentTx(UInt256 txHash)
{
if (!this.inTransaction)
{
throw new InvalidOperationException();
}
Api.JetSetCurrentIndex(this.jetSession, this.unspentTxTableId, "IX_TxHash");
Api.MakeKey(this.jetSession, this.unspentTxTableId, DbEncoder.EncodeUInt256(txHash), MakeKeyGrbit.NewKey);
if (Api.TrySeek(this.jetSession, this.unspentTxTableId, SeekGrbit.SeekEQ))
{
var addedBlockIndex = Api.RetrieveColumnAsInt32(this.jetSession, this.unspentTxTableId, this.blockIndexColumnId).Value;
var txIndex = Api.RetrieveColumnAsInt32(this.jetSession, this.unspentTxTableId, this.txIndexColumnId).Value;
var outputStates = DataEncoder.DecodeOutputStates(Api.RetrieveColumn(this.jetSession, this.unspentTxTableId, this.outputStatesColumnId));
Api.JetDelete(this.jetSession, this.unspentTxTableId);
// decrease unspent tx count
Api.EscrowUpdate(this.jetSession, this.globalsTableId, this.unspentTxCountColumnId, -1);
return(true);
}
else
{
return(false);
}
}
public WebRequest ToWebRequest(IClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
//Make a request
WebRequest request = WebRequest.Create(GetUri(client));
request.Method = "GET";
if (Type == RequestType.Activate)
{
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
using (Stream requestStream = request.GetRequestStream())
{
using (var writer = new StreamWriter(requestStream))
{
writer.Write(string.Format("{1}={0}&",
DataEncoder.ToString(client.GetCertificateExports()),
"cert"));
writer.Write(string.Format("{1}={0}", DataEncoder.ToString(LicenseKey),
"lid"));
}
}
}
return(request);
}
public string ToOfflineData()
{
using (var memoryStream = new MemoryStream())
{
using (var writer = new BinaryWriter(memoryStream))
{
var header = (byte)((byte)Type << 7 | ClientId.Length);
writer.Write(header);
writer.Write(ClientId);
if (Type == RequestType.Activate)
{
//Write cert and license data
writer.Write((ushort)Certificate.Length);
writer.Write(Certificate);
if (LicenseKey.Length > 0)
{
writer.Write((ushort)LicenseKey.Length);
writer.Write(LicenseKey);
}
}
var data = memoryStream.ToArray();
var signBuffer = RSASigner.GetSignBuffer(data, new[] { HashSecret.GetSecret() });
writer.Write(SHA512.Create().ComputeHash(signBuffer));
return(DataEncoder.ToHexString(memoryStream.ToArray()));
}
}
}
public SpentTransactionsStorage(string baseDirectory)
: base(baseDirectory, "SpentTransactions",
keyPairs =>
{
using (var stream = new MemoryStream())
{
foreach (var keyPair in keyPairs)
{
DataEncoder.EncodeUInt256(stream, keyPair.Key);
DataEncoder.EncodeSpentTx(stream, keyPair.Value);
}
return(stream.ToArray());
}
},
(blockHash, bytes) =>
{
using (var stream = new MemoryStream(bytes))
{
var keyPairs = ImmutableList.CreateBuilder <KeyValuePair <UInt256, SpentTx> >();
while (stream.Position < stream.Length)
{
var txHash = DataEncoder.DecodeUInt256(stream);
var spentTx = DataEncoder.DecodeSpentTx(stream);
keyPairs.Add(new KeyValuePair <UInt256, SpentTx>(txHash, spentTx));
}
return(keyPairs.ToImmutable());
}
})
{ }
public WriteBatch CreateWriteBatch()
{
var writeBatch = new WriteBatch();
try
{
foreach (var update in updates)
{
var txIndex = update.Key;
var blockTxNode = update.Value;
var key = DbEncoder.EncodeBlockHashTxIndex(blockHash, txIndex);
if (blockTxNode != null)
{
writeBatch.Put(key, DataEncoder.EncodeBlockTxNode(blockTxNode));
}
else
{
writeBatch.Delete(key);
}
}
return(writeBatch);
}
catch (Exception)
{
writeBatch.Dispose();
throw;
}
}
public UpOrderPacker(string simnum)
{
this.simnum = simnum;
this.encoder = new DataEncoder();
this.decoder = new DataDecoder();
this.orderID = (ushort)DateTime.Now.Millisecond;
}
public ChainedHeader FindMaxTotalWork()
{
using (var handle = this.cursorCache.TakeItem())
{
var cursor = handle.Item;
Api.JetSetCurrentIndex(cursor.jetSession, cursor.blockHeadersTableId, "IX_TotalWork");
// IX_TotalWork is in reverse order, so higher total work comes first
if (Api.TryMoveFirst(cursor.jetSession, cursor.blockHeadersTableId))
{
do
{
// check if this block is valid
var valid = Api.RetrieveColumnAsBoolean(cursor.jetSession, cursor.blockHeadersTableId, cursor.blockHeaderValidColumnId);
if (valid == null || valid.Value)
{
// decode chained header with most work and return
var chainedHeader = DataEncoder.DecodeChainedHeader(Api.RetrieveColumn(cursor.jetSession, cursor.blockHeadersTableId, cursor.blockHeaderBytesColumnId));
return(chainedHeader);
}
} while (Api.TryMoveNext(cursor.jetSession, cursor.blockHeadersTableId));
}
// no valid chained header found
return(null);
}
}
public bool TryAddBlockUnmintedTxes(UInt256 blockHash, IImmutableList <UnmintedTx> unmintedTxes)
{
CheckWriteTransaction();
try
{
using (SetSessionContext())
using (var jetUpdate = this.jetSession.BeginUpdate(this.unmintedTxTableId, JET_prep.Insert))
{
byte[] unmintedTxesBytes;
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.WriteList(unmintedTxes, unmintedTx => DataEncoder.EncodeUnmintedTx(writer, unmintedTx));
unmintedTxesBytes = stream.ToArray();
}
Api.SetColumns(this.jetSession, this.unmintedTxTableId,
new BytesColumnValue {
Columnid = this.unmintedBlockHashColumnId, Value = DbEncoder.EncodeUInt256(blockHash)
},
new BytesColumnValue {
Columnid = this.unmintedDataColumnId, Value = unmintedTxesBytes
});
jetUpdate.Save();
}
return(true);
}
catch (EsentKeyDuplicateException)
{
return(false);
}
}
public static LicenseInfo Deserialize(string serialized)
{
var info = new LicenseInfo();
try
{
var doc = XDocument.Parse(serialized).Root;
info.Issued = DateTime.FromFileTimeUtc(long.Parse(doc.Element("issued").Value));
info.ValidTo = DateTime.FromFileTimeUtc(long.Parse(doc.Element("valid").Value));
info.Features = doc.Element("params").Elements("feature").ToDictionary(x => x.Attribute("name").Value,
y => y.Attribute("value").Value);
info.Limits = doc.Element("params").Elements("limit").ToDictionary(x => x.Attribute("name").Value,
y => y.Attribute("value").Value);
info.CodeExecutionChain = doc.Element("params").Elements("execute").ToDictionary(x => x.Attribute("entry").Value,
y => DataEncoder.FromString(y.Value));
info.CustomValidators =
doc.Element("params").Elements("validate").Select(x => DataEncoder.FromString(x.Value)).ToList();
//Try execute
foreach (var codeExec in info.CodeExecutionChain)
{
var asembly = Assembly.Load(codeExec.Value);
var typeToCreate = asembly.GetType(codeExec.Key, true);
Activator.CreateInstance(typeToCreate);
}
}
catch (Exception e)
{
throw new LicenseValidationException("Can't parse", e);
}
return(info);
}
public bool TryAddUnspentTxOutput(TxOutputKey txOutputKey, TxOutput txOutput)
{
CheckWriteTransaction();
using (SetSessionContext())
{
try
{
using (var jetUpdate = this.jetSession.BeginUpdate(this.unspentTxOutputTableId, JET_prep.Insert))
{
Api.SetColumns(this.jetSession, this.unspentTxOutputTableId,
new BytesColumnValue {
Columnid = this.txOutputKeyColumnId, Value = DbEncoder.EncodeTxOutputKey(txOutputKey)
},
new BytesColumnValue {
Columnid = this.txOutputBytesColumnId, Value = DataEncoder.EncodeTxOutput(txOutput)
});
jetUpdate.Save();
}
return(true);
}
catch (EsentKeyDuplicateException)
{
return(false);
}
}
}
public bool TryAddBlockSpentTxes(int blockIndex, BlockSpentTxes spentTxes)
{
CheckWriteTransaction();
try
{
using (SetSessionContext())
using (var jetUpdate = this.jetSession.BeginUpdate(this.spentTxTableId, JET_prep.Insert))
{
byte[] spentTxesBytes;
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
writer.WriteList <SpentTx>(spentTxes, spentTx => DataEncoder.EncodeSpentTx(writer, spentTx));
spentTxesBytes = stream.ToArray();
}
Api.SetColumns(this.jetSession, this.spentTxTableId,
new Int32ColumnValue {
Columnid = this.spentSpentBlockIndexColumnId, Value = blockIndex
},
new BytesColumnValue {
Columnid = this.spentDataColumnId, Value = spentTxesBytes
});
jetUpdate.Save();
}
return(true);
}
catch (EsentKeyDuplicateException)
{
return(false);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jObject = JObject.Load(reader);
//var jObject = reader.Value as JObject;
return(DataEncoder.Encode(jObject?.ToString()));
}
public bool TryAddHeader(ChainedHeader header)
{
CheckWriteTransaction();
try
{
using (SetSessionContext())
using (var jetUpdate = this.jetSession.BeginUpdate(this.headersTableId, JET_prep.Insert))
{
Api.SetColumns(this.jetSession, this.headersTableId,
new BytesColumnValue {
Columnid = this.headerBlockHashColumnId, Value = DbEncoder.EncodeUInt256(header.Hash)
},
new BytesColumnValue {
Columnid = this.headerBytesColumnId, Value = DataEncoder.EncodeChainedHeader(header)
});
jetUpdate.Save();
}
return(true);
}
catch (EsentKeyDuplicateException)
{
return(false);
}
}
public SpentOutputsStorage(string baseDirectory)
: base(baseDirectory, "SpentOutputs",
keyPairs =>
{
using (var stream = new MemoryStream())
{
foreach (var keyPair in keyPairs)
{
DataEncoder.EncodeTxOutputKey(stream, keyPair.Key);
DataEncoder.EncodeTxOutput(stream, keyPair.Value);
}
return(stream.ToArray());
}
},
(blockHash, bytes) =>
{
using (var stream = new MemoryStream(bytes))
{
var keyPairs = ImmutableList.CreateBuilder <KeyValuePair <TxOutputKey, TxOutput> >();
while (stream.Position < stream.Length)
{
var txOutputKey = DataEncoder.DecodeTxOutputKey(stream);
var txOutput = DataEncoder.DecodeTxOutput(stream);
keyPairs.Add(new KeyValuePair <TxOutputKey, TxOutput>(txOutputKey, txOutput));
}
return(keyPairs.ToImmutable());
}
})
{ }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var bsonDocument = value as BsonDocument;
var json = DataEncoder.DecodeToJson(bsonDocument);
writer.WriteRawValue(json);
}
private static void WriteFile(string path)
{
string[] channels = { "up", "down", "top", "bottom", "charm", "strange" };
var rand = new Random(123456);
int totalPoints = 0, totalChannels = 0;
using (var encoder = new DataEncoder(path, "My file"))
{
for (int i = 0; i < 100; i++)
{
var channel = new Channel {
Name = channels[rand.Next(channels.Length)]
};
int count = rand.Next(1, 50);
var data = new List <float>(count);
for (int j = 0; j < count; j++)
{
data.Add((float)rand.NextDouble());
}
channel.Points = data;
encoder.AddChannel(channel);
totalPoints += count;
totalChannels++;
}
}
Console.WriteLine("Wrote: {0} points in {1} channels; {2} bytes", totalPoints, totalChannels, new FileInfo(path).Length);
}
public void NormalOutputTest(CodeState state, byte expectedByte)
{
var output = new DataEncoder().EncodeUseCodeResponse(state);
Assert.AreEqual(1, output.Length);
Assert.AreEqual(expectedByte, output[0]);
}
public override int Read(byte[] buffer, int offset, int count)
{
while (
unreadBytes.Count < count &&
this.unspentTransactions.MoveNext()
)
{
var unspentTx = this.unspentTransactions.Current;
unreadBytes.AddRange(DataEncoder.EncodeUnspentTx(unspentTx));
}
var available = unreadBytes.Count;
if (available >= count)
{
unreadBytes.CopyTo(0, buffer, offset, count);
unreadBytes.RemoveRange(0, count);
this.totalBytes += count;
return(count);
}
else
{
unreadBytes.CopyTo(0, buffer, offset, available);
unreadBytes.Clear();
this.totalBytes += available;
return(available);
}
}
public bool TryGetOutput(TxOutputKey txOutputKey, out TxOutput txOutput)
{
Api.JetBeginTransaction2(this.jetSession, BeginTransactionGrbit.ReadOnly);
try
{
//Api.JetSetCurrentIndex(this.jetSession, this.unspentTxOutputsTableId, "IX_TxOutputKey");
Api.MakeKey(this.jetSession, this.unspentTxOutputsTableId, DataEncoder.EncodeTxOutputKey(txOutputKey), MakeKeyGrbit.NewKey);
if (Api.TrySeek(this.jetSession, this.unspentTxOutputsTableId, SeekGrbit.SeekEQ))
{
var txOutputBytes = Api.RetrieveColumn(this.jetSession, this.unspentTxOutputsTableId, this.txOutputSmallColumnId);
if (txOutputBytes == null)
{
txOutputBytes = Api.RetrieveColumn(this.jetSession, this.unspentTxOutputsTableId, this.txOutputLargeColumnId);
}
txOutput = DataEncoder.DecodeTxOutput(txOutputBytes);
return(true);
}
else
{
txOutput = default(TxOutput);
return(false);
}
}
finally
{
Api.JetCommitTransaction(this.jetSession, CommitTransactionGrbit.LazyFlush);
}
}
public bool TryGetTransaction(UInt256 txHash, out UnspentTx unspentTx)
{
Api.JetBeginTransaction2(this.jetSession, BeginTransactionGrbit.ReadOnly);
try
{
//Api.JetSetCurrentIndex(this.jetSession, this.unspentTxTableId, "IX_TxHash");
Api.MakeKey(this.jetSession, this.unspentTxTableId, txHash.ToByteArray(), MakeKeyGrbit.NewKey);
if (Api.TrySeek(this.jetSession, this.unspentTxTableId, SeekGrbit.SeekEQ))
{
var confirmedBlockHash = new UInt256(Api.RetrieveColumn(this.jetSession, this.unspentTxTableId, this.confirmedBlockHashColumnId));
var outputStates = DataEncoder.DecodeOutputStates(Api.RetrieveColumn(this.jetSession, this.unspentTxTableId, this.outputStatesColumnId));
unspentTx = new UnspentTx(confirmedBlockHash, outputStates);
return(true);
}
else
{
unspentTx = default(UnspentTx);
return(false);
}
}
finally
{
Api.JetCommitTransaction(this.jetSession, CommitTransactionGrbit.LazyFlush);
}
}
public BlockHeader MineBlockHeader(BlockHeader blockHeader, UInt256 hashTarget)
{
var blockHeaderBytes = DataEncoder.EncodeBlockHeader(blockHeader);
var hashTargetBytes = hashTarget.ToByteArray();
var start = 0;
var finish = UInt32.MaxValue;
var total = 0L;
var nonceIndex = 76;
var minedNonce = (UInt32?)null;
this.logger.Debug("Starting mining: {0}".Format2(DateTime.Now.ToString("hh:mm:ss")));
var stopwatch = Stopwatch.StartNew();
Parallel.For(
start, finish,
new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount * 2
},
() => new LocalMinerState(blockHeaderBytes),
(nonceLong, loopState, localState) =>
{
localState.total++;
var nonce = (UInt32)nonceLong;
var nonceBytes = Bits.GetBytes(nonce);
Buffer.BlockCopy(nonceBytes, 0, localState.headerBytes, nonceIndex, 4);
var headerBytes = localState.headerBytes;
var sha256 = localState.sha256;
var hashBytes = sha256.ComputeDoubleHash(headerBytes);
if (BytesCompareLE(hashBytes, hashTargetBytes) < 0)
{
minedNonce = nonce;
loopState.Stop();
}
return(localState);
},
localState => { Interlocked.Add(ref total, localState.total); });
stopwatch.Stop();
var hashRate = ((float)total / 1000 / 1000) / ((float)stopwatch.ElapsedMilliseconds / 1000);
if (minedNonce != null)
{
this.logger.Debug("Found block in {0} hh:mm:ss at Nonce {1}, Hash Rate: {2} mHash/s, Total Hash Attempts: {3}, Found Hash: {4}".Format2(stopwatch.Elapsed.ToString(@"hh\:mm\:ss"), minedNonce, hashRate, total.ToString("#,##0"), blockHeader.With(Nonce: minedNonce).Hash));
return(blockHeader.With(Nonce: minedNonce));
}
else
{
this.logger.Debug("No block found in {0} hh:mm:ss, Hash Rate: {1} mHash/s, Total Hash Attempts: {2}, Found Hash: {3}".Format2(stopwatch.Elapsed.ToString(@"hh\:mm\:ss"), hashRate, total.ToString("#,##0"), blockHeader.With(Nonce: minedNonce).Hash));
return(null);
}
}
public async Task SendBlock(Block block)
{
await Task.Yield();
var sendBlockMessage = Messaging.ConstructMessage("block", DataEncoder.EncodeBlock(block));
await SendMessageAsync(sendBlockMessage);
}
public async Task SendTransaction(Transaction transaction)
{
await Task.Yield();
var sendTxMessage = Messaging.ConstructMessage("tx", DataEncoder.EncodeTransaction(transaction));
await SendMessageAsync(sendTxMessage);
}
private byte[] GetCallbackDescriptionFrame(Message message)
{
var entryCount = (ushort)message.CallbackPoint.Count();
var offset = GetCallbacksStartFrame(message);
return(DataEncoder.Combine(offset, entryCount, FramesPerCallbackEntry)
.GetBytes());
}
