/// <summary>
///
/// </summary>
/// <param name="signMessageRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerIdentifier"></param>
/// <param name="correlationId"></param>
protected override void HandleResponse(SignMessageResponse signMessageRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerIdentifier,
ICorrelationId correlationId)
{
Guard.Argument(signMessageRequest, nameof(signMessageRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerIdentifier, nameof(senderPeerIdentifier)).NotNull();
Logger.Debug(@"sign message response");
try
{
var decodeResult = MultiBase.Decode(signMessageRequest.OriginalMessage.ToByteArray().ToString());
Guard.Argument(decodeResult, nameof(decodeResult)).NotNull("The sign message response cannot be null.");
var originalMessage = decodeResult.ToHexString();
Guard.Argument(originalMessage, nameof(originalMessage)).NotNull();
_output.WriteLine(
$@"Signature: {signMessageRequest.Signature.ToByteArray().ToBase32()} " +
$@"Public Key: {signMessageRequest.PublicKey.ToByteArray().ToBase32()} Original Message: {originalMessage}");
}
catch (Exception ex)
{
Logger.Error(ex,
"Failed to handle SignMessageResponseHandler after receiving message {0}", signMessageRequest);
_output.WriteLine(ex.Message);
}
finally
{
Logger.Information("Press Enter to continue ...");
}
}
public void Invalid_Encoded_String()
{
foreach (var alg in MultiBaseAlgorithm.All)
{
var bad = alg.Code + "?";
Assert.Throws <FormatException>(() => MultiBase.Decode(bad));
}
}
public void Codec()
{
var bytes = new byte[] { 1, 2, 3, 4, 5 };
var bytes1 = MultiBase.Decode(MultiBase.Encode(bytes));
var bytes2 = MultiBase.Decode(MultiBase.Encode(bytes, "base16"));
bytes.Should().Contain(bytes1);
bytes.Should().Contain(bytes2);
}
public void Encode_Unknown_Algorithm()
{
var bytes = new byte[]
{
1, 2, 3, 4, 5
};
ExceptionAssert.Throws <KeyNotFoundException>(() => MultiBase.Encode(bytes, "unknown"));
}
public void EmptyData()
{
var empty = new byte[0];
foreach (var alg in MultiBaseAlgorithm.All)
{
var s = MultiBase.Encode(empty, alg.Name);
empty.Should().Equal(MultiBase.Decode(s), alg.Name);
}
}
public void CheckMultiBase()
{
foreach (var v in TestVectors)
{
var bytes = Encoding.UTF8.GetBytes(v.Input);
var s = MultiBase.Encode(bytes, v.Algorithm);
Assert.AreEqual(v.Output, s);
CollectionAssert.AreEqual(bytes, MultiBase.Decode(s));
}
}
public void EmptyData()
{
var empty = new byte[0];
foreach (var alg in MultiBaseAlgorithm.All)
{
var s = MultiBase.Encode(empty, alg.Name);
CollectionAssert.AreEqual(empty, MultiBase.Decode(s), alg.Name);
}
}
public void CheckMultiBase()
{
foreach (var v in TestVectors)
{
var bytes = Encoding.UTF8.GetBytes(v.Input);
var s = MultiBase.Encode(bytes, v.Algorithm);
Assert.Equal(v.Output, s);
bytes.Should().Contain(MultiBase.Decode(s));
}
}
public void Decode_Bad_Formats()
{
Assert.Throws <ArgumentNullException>(() => MultiBase.Decode(null));
Assert.Throws <ArgumentNullException>(() => MultiBase.Decode(""));
Assert.Throws <ArgumentNullException>(() => MultiBase.Decode(" "));
Assert.Throws <FormatException>(() => MultiBase.Decode("?"));
Assert.Throws <FormatException>(() => MultiBase.Decode("??"));
Assert.Throws <FormatException>(() => MultiBase.Decode("???"));
Assert.Throws <FormatException>(() => MultiBase.Decode("fXX"));
}
private static SignedResponse SignMessage(string messageToSign, string signature, string pubKey)
{
var signedResponse = new SignedResponse
{
Signature = signature.ToUtf8ByteString(),
PublicKey = pubKey.ToUtf8ByteString(),
OriginalMessage = MultiBase.Encode(messageToSign.FromBase32()).ToUtf8ByteString()
};
return(signedResponse);
}
public void Codec()
{
var bytes = new byte[]
{
1, 2, 3, 4, 5
};
var bytes1 = MultiBase.Decode(MultiBase.Encode(bytes));
var bytes2 = MultiBase.Decode(MultiBase.Encode(bytes, "base16"));
CollectionAssert.AreEqual(bytes, bytes1);
CollectionAssert.AreEqual(bytes, bytes2);
}
public void Cli_Can_Request_Node_Info()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
var hash = hashProvider.ComputeUtf8MultiHash("hello").ToCid();
var result = Shell.ParseCommand("getdelta", "-h", hash, NodeArgumentPrefix, ServerNodeName);
result.Should().BeTrue();
var request = AssertSentMessageAndGetMessageContent <GetDeltaRequest>();
MultiBase.Encode(request.DeltaDfsHash.ToByteArray(), "base32").Should().Be(hash);
}
public FavouriteDeltaObserverTests()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_deltaElector = Substitute.For <IDeltaElector>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_voterId = PeerIdHelper.GetPeerId("favourite delta voter");
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
_favouriteDeltaObserver = new FavouriteDeltaObserver(_deltaElector, hashProvider, logger);
_newHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("newHash").CreateCid());
_prevHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("prevHash").CreateCid());
}
public void Execute(DeltaBuilderContext context)
{
byte[] salt = GetSaltFromPreviousDelta(context.PreviousDeltaHash);
IEnumerable <RawEntryWithSaltedAndHashedEntry> rawAndSaltedEntriesBySignature = context.Transactions.Select(e => new RawEntryWithSaltedAndHashedEntry(e, salt, _hashProvider));
// (Eα;Oα)
byte[] shuffledEntriesBytes = rawAndSaltedEntriesBySignature
.OrderBy(v => v.SaltedAndHashedEntry, ByteUtil.ByteListComparer.Default)
.SelectMany(v => v.RawEntry.ToByteArray())
.ToArray();
// dn
byte[] signaturesInOrder = context.Transactions
.Select(p => p.Signature.ToByteArray())
.OrderBy(s => s, ByteUtil.ByteListComparer.Default)
.SelectMany(b => b)
.ToArray();
// xf
UInt256 summedFees = context.Transactions.Sum(t => t.GasPrice.ToUInt256() * t.GasLimit);
//∆Ln,j = L(f/E) + dn + E(xf, j)
context.CoinbaseEntry = new CoinbaseEntry
{
Amount = summedFees.ToUint256ByteString(),
ReceiverPublicKey = _producerUniqueId.PublicKey.ToByteString()
};
byte[] globalLedgerStateUpdate = shuffledEntriesBytes
.Concat(signaturesInOrder)
.Concat(context.CoinbaseEntry.ToByteArray())
.ToArray();
//hj
CandidateDeltaBroadcast candidate = new CandidateDeltaBroadcast
{
// h∆j
Hash = MultiBase.Decode(_hashProvider.ComputeMultiHash(globalLedgerStateUpdate).ToCid())
.ToByteString(),
// Idj
ProducerId = _producerUniqueId,
PreviousDeltaDfsHash = context.PreviousDeltaHash.ToArray().ToByteString()
};
context.Candidate = candidate;
}
protected override GetDeltaRequest GetMessage(GetDeltaOptions option)
{
try
{
var hashBytes = MultiBase.Decode(option.Hash);
var cid = hashBytes.ToCid();
new MultiHash(cid.Hash.ToArray());
return(new GetDeltaRequest {
DeltaDfsHash = hashBytes.ToByteString()
});
}
catch (FormatException fe)
{
Log.Warning("Unable to parse hash {0} as a Cid {1}", option.Hash, fe);
CommandContext.UserOutput.WriteLine($"Unable to parse hash {option.Hash} as a Cid");
return(default);
public void DeltaDfsHashBroadcastDao_DeltaDfsHashBroadcast_Should_Be_Convertible()
{
var hash = MultiBase.Decode(_hashProvider.ComputeUtf8MultiHash("this hash").CreateCid());
var previousDfsHash =
MultiBase.Decode(_hashProvider.ComputeUtf8MultiHash("previousDfsHash").CreateCid());
var original = new DeltaDfsHashBroadcast
{
DeltaDfsHash = hash.ToByteString(),
PreviousDeltaDfsHash = previousDfsHash.ToByteString()
};
var contextDao = original.ToDao <DeltaDfsHashBroadcast, DeltaDfsHashBroadcastDao>(_mapperProvider);
var reconverted = contextDao.ToProtoBuff <DeltaDfsHashBroadcastDao, DeltaDfsHashBroadcast>(_mapperProvider);
reconverted.Should().Be(original);
}
public static CandidateDeltaBroadcast GetCandidateDelta(IHashProvider hashProvider,
Cid previousDeltaHash = null,
Cid hash = null,
PeerId producerId = null)
{
var candidateHash = hash ??
hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32)).CreateCid();
var previousHash = previousDeltaHash ??
hashProvider.ComputeMultiHash(ByteUtil.GenerateRandomByteArray(32)).CreateCid();
var producer = producerId
?? PeerIdHelper.GetPeerId(ByteUtil.GenerateRandomByteArray(32));
return(new CandidateDeltaBroadcast
{
Hash = MultiBase.Decode(candidateHash).ToByteString(),
PreviousDeltaDfsHash = MultiBase.Decode(previousHash).ToByteString(),
ProducerId = producer
});
}
public void CandidateDeltaBroadcastDao_CandidateDeltaBroadcast_Should_Be_Convertible()
{
var previousHash = _hashProvider.ComputeMultiHash(Encoding.UTF8.GetBytes("previousHash"));
var hash = _hashProvider.ComputeMultiHash(Encoding.UTF8.GetBytes("anotherHash"));
var original = new CandidateDeltaBroadcast
{
Hash = MultiBase.Decode(hash.CreateCid()).ToByteString(),
ProducerId = PeerIdHelper.GetPeerId("test"),
PreviousDeltaDfsHash = MultiBase.Decode(previousHash.CreateCid()).ToByteString()
};
var candidateDeltaBroadcast =
original.ToDao <CandidateDeltaBroadcast, CandidateDeltaBroadcastDao>(_mapperProvider);
var reconverted =
candidateDeltaBroadcast.ToProtoBuff <CandidateDeltaBroadcastDao, CandidateDeltaBroadcast>(
_mapperProvider);
reconverted.Should().Be(original);
}
public void Init()
{
var hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_deltaElector = Substitute.For <IDeltaElector>();
_fakeChannelContext = Substitute.For <IChannelHandlerContext>();
var logger = Substitute.For <ILogger>();
_voterId = PeerIdHelper.GetPeerId("favourite delta voter");
_producerId = PeerIdHelper.GetPeerId("candidate delta producer");
var peerRepository = Substitute.For <IPeerRepository>();
peerRepository.GetPeersByIpAndPublicKey(Arg.Any <ByteString>(), Arg.Any <ByteString>()).Returns(new List <Peer> {
new Peer()
});
_favouriteDeltaObserver = new FavouriteDeltaObserver(_deltaElector, new SyncState()
{
IsSynchronized = true
}, peerRepository, hashProvider, logger);
_newHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("newHash").ToCid());
_prevHash = MultiBase.Decode(hashProvider.ComputeUtf8MultiHash("prevHash").ToCid());
}
///<inheritdoc />
public CandidateDeltaBroadcast BuildCandidateDelta(Cid previousDeltaHash)
{
_logger.Error("Current height: " + _deltaIndexService.Height());
_logger.Debug("Building candidate delta locally");
var allTransactions = _transactionRetriever.GetMempoolTransactionsByPriority();
Guard.Argument(allTransactions, nameof(allTransactions))
.NotNull("Mempool content returned null, check the mempool is actively running");
var includedTransactions = GetValidTransactionsForDelta(allTransactions);
var salt = GetSaltFromPreviousDelta(previousDeltaHash);
var rawAndSaltedEntriesBySignature = includedTransactions.Select(
x => new RawEntryWithSaltedAndHashedEntry(x, salt, _hashProvider));
// (Eα;Oα)
var shuffledEntriesBytes = rawAndSaltedEntriesBySignature
.OrderBy(v => v.SaltedAndHashedEntry, ByteUtil.ByteListComparer.Default)
.SelectMany(v => v.RawEntry.ToByteArray())
.ToArray();
// dn
var signaturesInOrder = includedTransactions
.Select(p => p.Signature.ToByteArray())
.OrderBy(s => s, ByteUtil.ByteListComparer.Default)
.SelectMany(b => b)
.ToArray();
// xf
var summedFees = includedTransactions.Sum(t => t.TransactionFees.ToUInt256());
//∆Ln,j = L(f/E) + dn + E(xf, j)
var coinbaseEntry = new CoinbaseEntry
{
Amount = summedFees.ToUint256ByteString(),
ReceiverPublicKey = _producerUniqueId.PublicKey.ToByteString()
};
var globalLedgerStateUpdate = shuffledEntriesBytes
.Concat(signaturesInOrder)
.Concat(coinbaseEntry.ToByteArray())
.ToArray();
//hj
var candidate = new CandidateDeltaBroadcast
{
// h∆j
Hash = MultiBase.Decode(_hashProvider.ComputeMultiHash(globalLedgerStateUpdate).ToCid())
.ToByteString(),
// Idj
ProducerId = _producerUniqueId,
PreviousDeltaDfsHash = previousDeltaHash.ToArray().ToByteString()
};
_logger.Debug("Building full delta locally");
var producedDelta = new Delta
{
PreviousDeltaDfsHash = previousDeltaHash.ToArray().ToByteString(),
MerkleRoot = candidate.Hash,
CoinbaseEntries = { coinbaseEntry },
PublicEntries = { includedTransactions },
TimeStamp = Timestamp.FromDateTime(_dateTimeProvider.UtcNow)
};
_logger.Debug("Adding local candidate delta");
_deltaCache.AddLocalDelta(candidate, producedDelta);
return(candidate);
}
public static string GetLocalDeltaCacheKey(CandidateDeltaBroadcast candidate)
{
return(nameof(DeltaCache) + "-LocalDelta-" + MultiBase.Encode(candidate.Hash.ToByteArray(), "base32"));
}
public ByteString Convert(string sourceMember, ResolutionContext context)
{
return(MultiBase.Decode(sourceMember).ToByteString());
}
public string Convert(ByteString sourceMember, ResolutionContext context)
{
return(MultiBase.Encode(sourceMember.ToByteArray(), "base32"));
}
public IDeterministicRandom GetDeterministicRandomFromSeed(byte[] seed)
{
return(new IsaacRandom(MultiBase.Encode(seed, "base16")));
}
public static Cid ToCid(this byte[] cid)
{
return(Cid.Decode(MultiBase.Encode(cid, Encoding)));
}
public void Encode_Null_Data_Not_Allowed()
{
Assert.Throws <ArgumentNullException>(() => MultiBase.Encode(null));
}
