/// <inheritdoc />
public bool TryUpdateLatestHash(Cid previousHash, Cid newHash)
{
_logger.Debug("New hash {hash} received for previous hash {previousHash}",
newHash, previousHash);
var foundNewDelta = _deltaCache.TryGetOrAddConfirmedDelta(newHash, out var newDelta);
var foundPreviousDelta = _deltaCache.TryGetOrAddConfirmedDelta(previousHash, out var previousDelta);
if (!foundPreviousDelta)
{
_logger.Warning("Failed to update latest hash from {previousHash} to {newHash} due to previous delta not found",
previousHash, newHash);
return(false);
}
if (!foundNewDelta)
{
_logger.Warning("Failed to update latest hash from {previousHash} to {newHash} due to new delta not found", previousHash, newHash);
return(false);
}
if (newDelta.PreviousDeltaDfsHash != previousHash.ToArray().ToByteString())
{
_logger.Warning("Failed to update latest hash from {previousHash} to {newHash} due to new delta not being a childe of the previous one",
previousHash, newHash);
return(false);
}
if (previousDelta.TimeStamp >= newDelta.TimeStamp)
{
_logger.Warning("Failed to update latest hash from {previousHash} to {newHash} due to new delta being older {newTimestamp} than the previous one {oldTimestamp}",
previousHash, newHash, newDelta.TimeStamp, previousDelta.TimeStamp);
return(false);
}
_logger.Debug("Successfully to updated latest hash from {previousHash} to {newHash}",
previousHash, newHash);
lock (_hashesByTimeDescending)
{
if (_hashesByTimeDescending.ContainsValue(newHash))
{
return(false);
}
_hashesByTimeDescending.Add(newDelta.TimeStamp, newHash);
if (_hashesByTimeDescending.Count > _capacity)
{
_hashesByTimeDescending.RemoveAt(_capacity);
}
}
_deltaHashUpdatesSubject.OnNext(newHash);
return(true);
}
private void SetCacheExpectations(Dictionary <Cid, Delta> deltasByHash)
{
foreach (var delta in deltasByHash)
{
_deltaCache.TryGetOrAddConfirmedDelta(delta.Key, out Arg.Any <Delta>())
.Returns(ci =>
{
ci[1] = delta.Value;
return(true);
});
}
}
public DeltaHashProvider(IDeltaCache deltaCache,
IDeltaIndexService deltaIndexService,
ILogger logger,
int capacity = 10_000)
{
_deltaCache = deltaCache;
_logger = logger;
_deltaHashUpdatesSubject = new ReplaySubject <Cid>(0);
var comparer = ComparerBuilder.For <Timestamp>().OrderBy(u => u, descending: true);
_capacity = capacity;
_hashesByTimeDescending = new SortedList <Timestamp, Cid>(comparer)
{
Capacity = _capacity
};
var latestDeltaIndex = deltaIndexService.LatestDeltaIndex();
if (deltaIndexService.LatestDeltaIndex() != null)
{
var foundDelta = _deltaCache.TryGetOrAddConfirmedDelta(latestDeltaIndex.Cid, out var delta);
_hashesByTimeDescending.Add(delta.TimeStamp, latestDeltaIndex.Cid);
return;
}
_hashesByTimeDescending.Add(Timestamp.FromDateTime(DateTime.UnixEpoch), _deltaCache.GenesisHash);
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_random = new Random(1);
_randomFactory = Substitute.For <IDeterministicRandomFactory>();
_randomFactory.GetDeterministicRandomFromSeed(Arg.Any <byte[]>())
.Returns(ci => new IsaacRandom(((byte[])ci[0]).ToHex()));
_producerId = PeerIdHelper.GetPeerId("producer");
_peerSettings = _producerId.ToSubstitutedPeerSettings();
_previousDeltaHash = _hashProvider.ComputeUtf8MultiHash("previousDelta").ToCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
Delta previousDelta = new Delta();
previousDelta.StateRoot = ByteString.CopyFrom(Keccak.EmptyTreeHash.Bytes);
_cache.TryGetOrAddConfirmedDelta(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x =>
{
x[1] = previousDelta;
return(true);
});
_dateTimeProvider = new DateTimeProvider();
IDb codeDb = new MemDb();
ISnapshotableDb stateDb = new StateDb();
ISpecProvider specProvider = new CatalystSpecProvider();
_cryptoContext = new FfiWrapper();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
IStorageProvider storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
KatVirtualMachine virtualMachine = new KatVirtualMachine(_stateProvider,
storageProvider,
new StateUpdateHashProvider(),
specProvider,
new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256")),
new FfiWrapper(),
LimboLogs.Instance);
_deltaExecutor = new DeltaExecutor(specProvider,
_stateProvider,
storageProvider,
virtualMachine,
_cryptoContext,
_logger);
}
private Delta CreateAndExpectDeltaFromCache(MultiHash hash)
{
var delta = DeltaHelper.GetDelta(_hashProvider);
_deltaCache.TryGetOrAddConfirmedDelta(Arg.Is(hash), out Arg.Any <Delta>())
.Returns(ci =>
{
ci[1] = delta;
return(true);
});
return(delta);
}
public void Execute(DeltaBuilderContext context)
{
if (_logger.IsEnabled(LogEventLevel.Debug))
{
_logger.Debug("Resolving previous delta by hash ({previousHash})", context.PreviousDeltaHash);
}
if (!_deltaCache.TryGetOrAddConfirmedDelta(context.PreviousDeltaHash, out Delta previousDelta))
{
throw new InvalidDataException("Cannot retrieve previous delta from cache during delta construction.");
}
context.PreviousDelta = previousDelta;
}
/// <inheritdoc />
public bool TryUpdateLatestHash(MultiHash previousHash, MultiHash newHash)
{
var newAddress = newHash;
var previousAddress = previousHash;
_logger.Debug("New hash {hash} received for previous hash {previousHash}",
newAddress, previousAddress);
var foundNewDelta = _deltaCache.TryGetOrAddConfirmedDelta(newAddress, out var newDelta);
var foundPreviousDelta = _deltaCache.TryGetOrAddConfirmedDelta(previousAddress, out var previousDelta);
if (!foundNewDelta ||
!foundPreviousDelta ||
newDelta.PreviousDeltaDfsHash != previousHash.ToArray().ToByteString() ||
previousDelta.TimeStamp >= newDelta.TimeStamp)
{
_logger.Warning("Failed to update latest hash from {previousHash} to {newHash}",
previousAddress, newAddress);
return(false);
}
_logger.Debug("Successfully to updated latest hash from {previousHash} to {newHash}",
previousAddress, newAddress);
lock (_hashesByTimeDescending)
{
_hashesByTimeDescending.Add(newDelta.TimeStamp, newHash);
if (_hashesByTimeDescending.Count > _capacity)
{
_hashesByTimeDescending.RemoveAt(_capacity);
}
}
_deltaHashUpdatesSubject.OnNext(newAddress);
return(true);
}
bool TryFetchData(string transactionId, out Cid deltaHash, out Delta delta)
{
if (!_transactionToDeltaRepository.TryGet(transactionId, out var transactionToDelta))
{
deltaHash = null;
delta = null;
return(false);
}
deltaHash = transactionToDelta.DeltaHash;
if (!_deltaCache.TryGetOrAddConfirmedDelta(deltaHash, out delta))
{
return(false);
}
return(true);
}
protected override GetDeltaResponse HandleRequest(GetDeltaRequest getDeltaRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getDeltaRequest, nameof(getDeltaRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
Logger.Verbose("received message of type GetDeltaRequest:");
Logger.Verbose("{getDeltaRequest}", getDeltaRequest);
var cid = getDeltaRequest.DeltaDfsHash.ToByteArray().ToCid();
_deltaCache.TryGetOrAddConfirmedDelta(cid, out var delta);
return(new GetDeltaResponse {
Delta = delta
});
}