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 ConsensusTests()
{
var hashingAlgorithm = HashingAlgorithm.GetAlgorithmMetadata("blake2b-256");
_hashProvider = new HashProvider(hashingAlgorithm);
_cycleEventProvider = new TestCycleEventProvider();
_deltaBuilder = Substitute.For <IDeltaBuilder>();
_deltaVoter = Substitute.For <IDeltaVoter>();
_deltaElector = Substitute.For <IDeltaElector>();
_deltaCache = Substitute.For <IDeltaCache>();
_deltaHub = Substitute.For <IDeltaHub>();
var deltaHashProvider = Substitute.For <IDeltaHashProvider>();
var logger = Substitute.For <ILogger>();
_consensus = new Consensus(
_deltaBuilder,
_deltaVoter,
_deltaElector,
_deltaCache,
_deltaHub,
_cycleEventProvider,
deltaHashProvider,
_hashProvider,
logger);
_consensus.StartProducing();
}
public Synchroniser(SyncState syncState,
IPeerSyncManager peerSyncManager,
IDeltaCache deltaCache,
IDeltaHeightWatcher deltaHeightWatcher,
IDeltaHashProvider deltaHashProvider,
IDeltaDfsReader deltaDfsReader,
IDeltaIndexService deltaIndexService,
IMapperProvider mapperProvider,
IUserOutput userOutput,
ILogger logger,
int rangeSize = 20, //cannot go over 20 until udp network fragmentation is fixed
IScheduler scheduler = null)
{
State = syncState;
_peerSyncManager = peerSyncManager;
_deltaHeightWatcher = deltaHeightWatcher;
DeltaCache = deltaCache;
_rangeSize = rangeSize;
_deltaIndexService = deltaIndexService;
_mapperProvider = mapperProvider;
_userOutput = userOutput;
_deltaHashProvider = deltaHashProvider;
_logger = logger;
_syncCompletedReplaySubject = new ReplaySubject <ulong>(1, scheduler ?? Scheduler.Default);
SyncCompleted = _syncCompletedReplaySubject.AsObservable();
}
public DeltaBuilderTests()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_random = new Random();
_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").CreateCid();
_zeroCoinbaseEntry = new CoinbaseEntry
{
Amount = UInt256.Zero.ToUint256ByteString(),
ReceiverPublicKey = _producerId.PublicKey.ToByteString()
};
_logger = Substitute.For <ILogger>();
_cache = Substitute.For <IDeltaCache>();
_dateTimeProvider = new DateTimeProvider();
}
public void Init()
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_cycleEventProvider = new TestCycleEventProvider();
_deltaBuilder = Substitute.For <IDeltaBuilder>();
_deltaVoter = Substitute.For <IDeltaVoter>();
_deltaElector = Substitute.For <IDeltaElector>();
_deltaCache = Substitute.For <IDeltaCache>();
_deltaHub = Substitute.For <IDeltaHub>();
var deltaHashProvider = Substitute.For <IDeltaHashProvider>();
var logger = Substitute.For <ILogger>();
_syncState = new SyncState {
IsSynchronized = true, IsRunning = true
};
_ledger = Substitute.For <ILedger>();
_consensus = new Consensus(
_deltaBuilder,
_deltaVoter,
_deltaElector,
_deltaCache,
_deltaHub,
_cycleEventProvider,
deltaHashProvider,
logger);
_consensus.StartProducing();
}
public Web3EthApi(IStateReader stateReader,
IDeltaResolver deltaResolver,
IDeltaCache deltaCache,
IDeltaExecutor executor,
IStorageProvider storageProvider,
IStateProvider stateProvider,
ITransactionRepository receipts,
ITransactionReceivedEvent transactionReceived,
IPeerRepository peerRepository,
IMempool <PublicEntryDao> mempoolRepository,
IDfsService dfsService,
IHashProvider hashProvider,
SyncState syncState,
IMapperProvider mapperProvider,
IPeerSettings peerSettings)
{
_receipts = receipts;
_transactionReceived = transactionReceived ?? throw new ArgumentNullException(nameof(transactionReceived));
HashProvider = hashProvider;
_peerId = peerSettings.PeerId;
_mempoolRepository = mempoolRepository;
PeerRepository = peerRepository;
_mapperProvider = mapperProvider;
StateReader = stateReader ?? throw new ArgumentNullException(nameof(stateReader));
DeltaResolver = deltaResolver ?? throw new ArgumentNullException(nameof(deltaResolver));
DeltaCache = deltaCache ?? throw new ArgumentNullException(nameof(deltaCache));
Executor = executor ?? throw new ArgumentNullException(nameof(executor));
StorageProvider = storageProvider ?? throw new ArgumentNullException(nameof(storageProvider));
StateProvider = stateProvider ?? throw new ArgumentNullException(nameof(stateProvider));
DfsService = dfsService;
SyncState = syncState;
}
public GetDeltaRequestObserver(IHashProvider hashProvider,
IDeltaCache deltaCache,
IPeerSettings peerSettings,
ILogger logger) : base(logger, peerSettings)
{
_hashProvider = hashProvider;
_deltaCache = deltaCache;
}
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);
}
public TransactionRepository(IRepository <TransactionReceipts, string> repository,
IRepository <TransactionToDelta, string> transactionToDeltaRepository,
IHashProvider hashProvider,
IDeltaCache deltaCache)
{
_repository = repository;
_transactionToDeltaRepository = transactionToDeltaRepository;
_hashProvider = hashProvider;
_deltaCache = deltaCache;
}
public LedgerSynchroniserTests(ITestOutputHelper output)
{
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_output = output;
_deltaCache = Substitute.For <IDeltaCache>();
var logger = Substitute.For <ILogger>();
_cancellationToken = new CancellationToken();
_synchroniser = new LedgerSynchroniser(_deltaCache, logger);
}
public DeltaHashProviderTests(ITestOutputHelper output) : base(output)
{
_deltaCache = Substitute.For <IDeltaCache>();
_logger = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.TestOutput(output)
.CreateLogger()
.ForContext(MethodBase.GetCurrentMethod().DeclaringType);
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
_deltaCache.GenesisHash.Returns(
_hashProvider.ComputeMultiHash(new Delta().ToByteArray()).CreateCid());
}
public void Init()
{
this.Setup(TestContext.CurrentContext);
_deltaCache = Substitute.For <IDeltaCache>();
_logger = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.NUnitOutput()
.CreateLogger()
.ForContext(MethodBase.GetCurrentMethod().DeclaringType);
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_deltaCache.GenesisHash.Returns(
_hashProvider.ComputeMultiHash(new Delta().ToByteArray()).ToCid());
}
public DeltaBuilder(IDeltaTransactionRetriever transactionRetriever,
IDeterministicRandomFactory randomFactory,
IHashProvider hashProvider,
IPeerSettings peerSettings,
IDeltaCache deltaCache,
IDateTimeProvider dateTimeProvider,
ILogger logger)
{
_transactionRetriever = transactionRetriever;
_randomFactory = randomFactory;
_hashProvider = hashProvider;
_producerUniqueId = peerSettings.PeerId;
_deltaCache = deltaCache;
_dateTimeProvider = dateTimeProvider;
_logger = logger;
}
public DeltaHashProvider(IDeltaCache deltaCache,
ILogger logger,
int capacity = 10_000)
{
_deltaCache = deltaCache;
_logger = logger;
_deltaHashUpdatesSubject = new ReplaySubject <MultiHash>(0);
var comparer = ComparerBuilder.For <Timestamp>().OrderBy(u => u, descending: true);
_capacity = capacity;
_hashesByTimeDescending = new SortedList <Timestamp, MultiHash>(comparer)
{
Capacity = _capacity
};
_hashesByTimeDescending.Add(Timestamp.FromDateTime(DateTime.MinValue.ToUniversalTime()),
_deltaCache.GenesisHash);
}
public Consensus(IDeltaBuilder deltaBuilder,
IDeltaVoter deltaVoter,
IDeltaElector deltaElector,
IDeltaCache deltaCache,
IDeltaHub deltaHub,
ICycleEventsProvider cycleEventsProvider,
IDeltaHashProvider deltaHashProvider,
ILogger logger)
{
_deltaVoter = deltaVoter;
_deltaElector = deltaElector;
_cycleEventsProvider = cycleEventsProvider;
_deltaHashProvider = deltaHashProvider;
_deltaBuilder = deltaBuilder;
_deltaHub = deltaHub;
_deltaCache = deltaCache;
_logger = logger;
logger.Information("Consensus repository initialised.");
}
protected override BlockForRpc Handle(BlockParameter block, IWeb3EthApi api)
{
Cid deltaHash;
long blockNumber;
IDeltaCache deltaCache = api.DeltaCache;
IDeltaResolver deltaResolver = api.DeltaResolver;
switch (block.Type)
{
case BlockParameterType.Earliest:
deltaHash = deltaCache.GenesisHash;
blockNumber = 0;
break;
case BlockParameterType.Latest:
deltaHash = deltaResolver.LatestDelta;
blockNumber = deltaResolver.LatestDeltaNumber;
break;
case BlockParameterType.Pending:
deltaHash = deltaResolver.LatestDelta;
blockNumber = deltaResolver.LatestDeltaNumber;
break;
case BlockParameterType.BlockNumber:
blockNumber = block.BlockNumber.Value;
if (!deltaResolver.TryResolve(blockNumber, out deltaHash))
{
return(null);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
DeltaWithCid deltaWithCid = api.GetDeltaWithCid(deltaHash);
return(BuildBlock(deltaWithCid, blockNumber, api.HashProvider));
}
public GetDeltaRequestObserverTests()
{
var builder = new ContainerBuilder();
builder.RegisterModule <HashingModule>();
var container = builder.Build();
container.BeginLifetimeScope();
_hashProvider = container.Resolve <IHashProvider>();
_testScheduler = new TestScheduler();
var logger = Substitute.For <ILogger>();
var peerIdentifier = PeerIdHelper.GetPeerId("responder");
var peerSettings = peerIdentifier.ToSubstitutedPeerSettings();
_deltaCache = Substitute.For <IDeltaCache>();
_observer = new GetDeltaRequestObserver(_hashProvider, _deltaCache, peerSettings, logger);
_fakeContext = Substitute.For <IChannelHandlerContext>();
}
public PreviousDeltaResolverStep(IDeltaCache deltaCache, ILogger logger)
{
_deltaCache = deltaCache ?? throw new ArgumentNullException(nameof(deltaCache));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public DeltaRegistrationStep(IDeltaCache deltaCache, ILogger logger)
{
_deltaCache = deltaCache ?? throw new ArgumentNullException(nameof(deltaCache));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public GetDeltaRequestObserver(IDeltaCache deltaCache,
IPeerSettings peerSettings,
ILogger logger) : base(logger, peerSettings)
{
_deltaCache = deltaCache;
}
public LedgerSynchroniser(IDeltaCache deltaCache, IHashProvider hashProvider, ILogger logger)
{
DeltaCache = deltaCache;
_hashProvider = hashProvider;
_logger = logger;
}
public LedgerSynchroniser(IDeltaCache deltaCache, ILogger logger)
{
DeltaCache = deltaCache;
_logger = logger;
}
public void Init()
{
_cancellationToken = new CancellationToken();
_manualResetEventSlim = new ManualResetEventSlim(false);
_testScheduler = new TestScheduler();
_hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("keccak-256"));
_peerSettings = Substitute.For <IPeerSettings>();
_peerSettings.PeerId.Returns(PeerIdHelper.GetPeerId());
_deltaDfsReader = Substitute.For <IDeltaDfsReader>();
_deltaDfsReader.TryReadDeltaFromDfs(Arg.Any <Cid>(), out Arg.Any <Delta>()).Returns(x => true);
_deltaCache = Substitute.For <IDeltaCache>();
_deltaCache.GenesisHash.Returns("bafk2bzacecji5gcdd6lxsoazgnbg46c3vttjwwkptiw27enachziizhhkir2w".ToCid());
_ledger = Substitute.For <ILedger>();
_peerService = Substitute.For <IPeerService>();
_deltaHashProvider = new DeltaHashProvider(_deltaCache, Substitute.For <IDeltaIndexService>(), Substitute.For <ILogger>());
_deltaIndexService = new DeltaIndexService(new InMemoryRepository <DeltaIndexDao, string>());
_deltaIndexService.Add(new DeltaIndexDao {
Cid = _hashProvider.ComputeUtf8MultiHash("0").ToCid(), Height = 0
});
_peerClient = Substitute.For <IPeerClient>();
ModifyPeerClient <LatestDeltaHashRequest>((request, senderPeerIdentifier) =>
{
var deltaHeightResponse = new LatestDeltaHashResponse
{
DeltaIndex = new DeltaIndex
{
Cid = _hashProvider.ComputeUtf8MultiHash(_syncTestHeight.ToString()).ToCid().ToArray()
.ToByteString(),
Height = (uint)_syncTestHeight
}
};
_deltaHeightReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
deltaHeightResponse.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
ModifyPeerClient <DeltaHistoryRequest>((request, senderPeerIdentifier) =>
{
var data = GenerateSampleData((int)request.Height, (int)request.Range, (int)_syncTestHeight);
_deltaIndexService.Add(data.DeltaIndex.Select(x => DeltaIndexDao.ToDao <DeltaIndex>(x, _mapperProvider)));
_deltaHistoryReplaySubject.OnNext(new ObserverDto(Substitute.For <IChannelHandlerContext>(),
data
.ToProtocolMessage(senderPeerIdentifier, CorrelationId.GenerateCorrelationId())));
});
_peerRepository = new PeerRepository(new InMemoryRepository <Peer, string>());
Enumerable.Repeat(new Peer {
PeerId = PeerIdHelper.GetPeerId()
}, 5).ToList().ForEach(_peerRepository.Add);
_deltaHeightReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_deltaHistoryReplaySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
var mergeMessageStreams = _deltaHeightReplaySubject.AsObservable()
.Merge(_deltaHistoryReplaySubject.AsObservable());
_peerService.MessageStream.Returns(mergeMessageStreams);
_deltaHashProvider = Substitute.For <IDeltaHashProvider>();
_deltaHashProvider.TryUpdateLatestHash(Arg.Any <Cid>(), Arg.Any <Cid>()).Returns(true);
_mapperProvider = new TestMapperProvider();
_userOutput = Substitute.For <IUserOutput>();
_deltaHeightWatcher = new DeltaHeightWatcher(_peerClient, _peerRepository, _peerService, minimumPeers: 0);
var dfsService = Substitute.For <IDfsService>();
_peerSyncManager = new PeerSyncManager(_peerClient, _peerRepository,
_peerService, _userOutput, _deltaHeightWatcher, Substitute.For <IDfsService>(), 0.7, 0);
}
