private void AddAccount(StateProvider stateProvider, Address account, UInt256 initialBalance)
{
stateProvider.CreateAccount(account, initialBalance);
stateProvider.Commit(MuirGlacier.Instance, null);
stateProvider.CommitTree();
_dbProvider.StateDb.Commit();
}
public void Duplicate_state_method_throws()
{
using (new StateProviderFixture())
{
Assert.Throws <DuplicateStateMethodException>(() => { StateProvider.Setup <DuplicateStateMethods>(); });
}
}
public async IAsyncEnumerable <EntityState> GetStatesAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
{
var response = await HttpClient.GetAsync("states", HttpCompletionOption.ResponseHeadersRead, cancellationToken);
response.EnsureSuccessStatusCode();
var jsonSerializer = JsonSerializer.Create(JsonSerializerSettings);
using (var responseStream = await response.Content.ReadAsStreamAsync())
using (var streamReader = new StreamReader(responseStream))
using (var reader = new JsonTextReader(streamReader))
{
while (await reader.ReadAsync(cancellationToken))
{
if (reader.TokenType == JsonToken.StartObject)
{
var jObject = await JObject.LoadAsync(reader, cancellationToken);
var entityId = jObject["entity_id"]?.Value <string>() ?? throw new InvalidOperationException();
var state = jObject["state"]?.ToString();
var attributes = jObject["attributes"]?.ToObject <Dictionary <string, object> >() ?? throw new InvalidOperationException();
StateCodeGenerator.Observe(entityId, state, attributes);
var entityStateType = StateProvider.GetEntityStateType(entityId, attributes);
var entityState = (EntityState)jObject.ToObject(entityStateType, jsonSerializer);
yield return(entityState);
}
}
}
}
public void Calling_setup_once_does_not_throw()
{
using (new StateProviderFixture())
{
StateProvider.Setup(typeof(NoStates));
}
}
public void Reset()
{
StateProvider.Reset();
StorageProvider.Reset();
_codeDb.ClearTempChanges();
}
public ReadOnlyTxProcessingEnv(
IReadOnlyDbProvider?readOnlyDbProvider,
IReadOnlyTrieStore?readOnlyTrieStore,
IReadOnlyBlockTree?readOnlyBlockTree,
ISpecProvider?specProvider,
ILogManager?logManager)
{
if (specProvider == null)
{
throw new ArgumentNullException(nameof(specProvider));
}
DbProvider = readOnlyDbProvider ?? throw new ArgumentNullException(nameof(readOnlyDbProvider));
_codeDb = readOnlyDbProvider.CodeDb.AsReadOnly(true);
StateReader = new StateReader(readOnlyTrieStore, _codeDb, logManager);
StateProvider = new StateProvider(readOnlyTrieStore, _codeDb, logManager);
StorageProvider = new StorageProvider(readOnlyTrieStore, StateProvider, logManager);
IWorldState worldState = new WorldState(StateProvider, StorageProvider);
BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree));
BlockhashProvider = new BlockhashProvider(BlockTree, logManager);
Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager);
TransactionProcessor = new TransactionProcessor(specProvider, worldState, Machine, logManager);
}
public void Restore_update_restore()
{
StateProvider provider = new StateProvider(new TrieStore(new MemDb(), Logger), _codeDb, Logger);
provider.CreateAccount(_address1, 0);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(4);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.AddToBalance(_address1, 1, Frontier.Instance);
provider.Restore(4);
Assert.AreEqual((UInt256)4, provider.GetBalance(_address1));
}
public void Empty_commit_restore()
{
StateProvider provider = new StateProvider(new TrieStore(new MemDb(), Logger), _codeDb, Logger);
provider.Commit(Frontier.Instance);
provider.Restore(-1);
}
public void Returns_empty_byte_code_for_non_existing_accounts()
{
StateProvider provider = new StateProvider(new TrieStore(new MemDb(), Logger), _codeDb, Logger);
byte[] code = provider.GetCode(TestItem.AddressA);
code.Should().BeEmpty();
}
public async Task Can_ask_about_storage_in_parallel()
{
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
IReleaseSpec spec = MuirGlacier.Instance;
StateDb stateDb = new StateDb(new MemDb());
StateProvider provider = new StateProvider(stateDb, new MemDb(), Logger);
StorageProvider storageProvider = new StorageProvider(stateDb, provider, Logger);
void UpdateStorageValue(byte[] newValue)
{
storageProvider.Set(storageCell, newValue);
}
void AddOneToBalance()
{
provider.AddToBalance(_address1, 1, spec);
}
void CommitEverything()
{
storageProvider.Commit();
storageProvider.CommitTrees();
provider.Commit(spec);
provider.CommitTree();
}
provider.CreateAccount(_address1, 1);
CommitEverything();
AddOneToBalance();
UpdateStorageValue(new byte[] { 1 });
CommitEverything();
Keccak stateRoot0 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 2 });
CommitEverything();
Keccak stateRoot1 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 3 });
CommitEverything();
Keccak stateRoot2 = provider.StateRoot;
AddOneToBalance();
UpdateStorageValue(new byte[] { 4 });
CommitEverything();
Keccak stateRoot3 = provider.StateRoot;
stateDb.Commit();
StateReader reader = new StateReader(stateDb, Substitute.For <IDb>(), Logger);
Task a = StartStorageTask(reader, stateRoot0, storageCell, new byte[] { 1 });
Task b = StartStorageTask(reader, stateRoot1, storageCell, new byte[] { 2 });
Task c = StartStorageTask(reader, stateRoot2, storageCell, new byte[] { 3 });
Task d = StartStorageTask(reader, stateRoot3, storageCell, new byte[] { 4 });
await Task.WhenAll(a, b, c, d);
}
public void Non_existing()
{
StorageCell storageCell = new StorageCell(_address1, UInt256.One);
IReleaseSpec spec = MuirGlacier.Instance;
StateDb stateDb = new StateDb(new MemDb());
StateProvider provider = new StateProvider(stateDb, new MemDb(), Logger);
StorageProvider storageProvider = new StorageProvider(stateDb, provider, Logger);
void CommitEverything()
{
storageProvider.Commit();
storageProvider.CommitTrees();
provider.Commit(spec);
provider.CommitTree();
}
provider.CreateAccount(_address1, 1);
storageProvider.Set(storageCell, new byte[] { 1 });
CommitEverything();
Keccak stateRoot0 = provider.StateRoot;
stateDb.Commit();
StateReader reader = new StateReader(stateDb, Substitute.For <IDb>(), Logger);
Keccak storageRoot = reader.GetStorageRoot(stateRoot0, _address1);
reader.GetStorage(storageRoot, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 });
reader.GetStorage(Keccak.EmptyTreeHash, storageCell.Index + 1).Should().BeEquivalentTo(new byte[] { 0 });
}
public void Setup()
{
IDbProvider memDbProvider = TestMemDbProvider.Init();
TrieStore trieStore = new TrieStore(new MemDb(), LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(trieStore, new MemDb(), LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(trieStore, stateProvider, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(memDbProvider);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
IBloomStorage bloomStorage = NullBloomStorage.Instance;
EthereumEcdsa ecdsa = new EthereumEcdsa(1, LimboLogs.Instance);
TxPool.TxPool txPool = new TxPool.TxPool(
NullTxStorage.Instance,
ecdsa,
specProvider,
new TxPoolConfig(),
stateProvider,
LimboLogs.Instance);
_blockTree = new BlockTree(
memDbProvider,
chainLevelInfoRepository,
specProvider,
bloomStorage,
new SyncConfig(),
LimboLogs.Instance);
BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
specProvider,
LimboLogs.Instance);
TransactionProcessor transactionProcessor = new TransactionProcessor(
specProvider,
stateProvider,
storageProvider,
virtualMachine,
LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(
MainnetSpecProvider.Instance,
Always.Valid,
new RewardCalculator(specProvider),
transactionProcessor,
stateProvider,
storageProvider,
txPool,
NullReceiptStorage.Instance,
new WitnessCollector(memDbProvider.StateDb, LimboLogs.Instance),
LimboLogs.Instance);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
blockProcessor,
new RecoverSignatures(
ecdsa,
txPool,
specProvider,
LimboLogs.Instance),
LimboLogs.Instance, BlockchainProcessor.Options.Default);
}
public void GlobalSetup()
{
ISnapshotableDb codeDb = new StateDb();
ISnapshotableDb stateDb = new StateDb();
IDb blockInfoDb = new MemDb(10, 5);
ISpecProvider specProvider = MainNetSpecProvider.Instance;
IReleaseSpec spec = MainNetSpecProvider.Instance.GenesisSpec;
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
stateProvider.CreateAccount(Address.Zero, 1000.Ether());
stateProvider.Commit(spec);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
StateReader stateReader = new StateReader(stateDb, codeDb, LimboLogs.Instance);
ChainLevelInfoRepository chainLevelInfoRepository = new ChainLevelInfoRepository(blockInfoDb);
BlockTree blockTree = new BlockTree(new MemDb(), new MemDb(), blockInfoDb, chainLevelInfoRepository, specProvider, NullTxPool.Instance, LimboLogs.Instance);
_blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(stateProvider, storageProvider, _blockhashProvider, specProvider, LimboLogs.Instance);
Block genesisBlock = Build.A.Block.Genesis.TestObject;
blockTree.SuggestBlock(genesisBlock);
Block block1 = Build.A.Block.WithParent(genesisBlock).WithNumber(1).TestObject;
blockTree.SuggestBlock(block1);
TransactionProcessor transactionProcessor
= new TransactionProcessor(MainNetSpecProvider.Instance, stateProvider, storageProvider, _virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, AlwaysValidBlockValidator.Instance, new RewardCalculator(specProvider), transactionProcessor,
stateDb, codeDb, new MemDb(), stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
BlockchainProcessor blockchainProcessor = new BlockchainProcessor(
blockTree,
blockProcessor,
new TxSignaturesRecoveryStep(new EthereumEcdsa(specProvider, LimboLogs.Instance), NullTxPool.Instance, LimboLogs.Instance),
LimboLogs.Instance,
false,
false);
blockchainProcessor.Process(genesisBlock, ProcessingOptions.None, NullBlockTracer.Instance);
blockchainProcessor.Process(block1, ProcessingOptions.None, NullBlockTracer.Instance);
BlockchainBridge bridge = new BlockchainBridge(
stateReader,
stateProvider,
storageProvider,
blockTree,
NullTxPool.Instance,
NullReceiptStorage.Instance,
NullFilterStore.Instance,
NullFilterManager.Instance, new DevWallet(new WalletConfig(), LimboLogs.Instance), transactionProcessor, new EthereumEcdsa(MainNetSpecProvider.Instance, LimboLogs.Instance));
_ethModule = new EthModule(LimboLogs.Instance, bridge);
}
public void Setup()
{
IDb blocksDb = new MemDb();
IDb blocksInfoDb = new MemDb();
IDb headersDb = new MemDb();
ChainLevelInfoRepository repository = new ChainLevelInfoRepository(blocksInfoDb);
ISpecProvider specProvider = MainnetSpecProvider.Instance;
_blockTree = new BlockTree(blocksDb, headersDb, blocksInfoDb, repository, specProvider, NullTxPool.Instance, NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance);
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance);
TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, Always.Valid, NoBlockRewards.Instance, transactionProcessor, stateDb, codeDb, stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
var txRecovery = new TxSignaturesRecoveryStep(new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance), NullTxPool.Instance, specProvider, LimboLogs.Instance);
_processor = new BlockchainProcessor(_blockTree, blockProcessor, txRecovery, LimboLogs.Instance, BlockchainProcessor.Options.NoReceipts);
Block genesis = Build.A.Block.Genesis.TestObject;
_blockTree.SuggestBlock(genesis);
_processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.Instance);
_tracer = new Tracer(stateProvider, _processor);
}
public void GlobalSetup()
{
ByteCode = Bytes.FromHexString(Environment.GetEnvironmentVariable("NETH.BENCHMARK.BYTECODE"));
Console.WriteLine($"Running benchmark for bytecode {ByteCode?.ToHexString()}");
IDb codeDb = new StateDb();
ISnapshotableDb stateDb = new StateDb();
_stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
_stateProvider.CreateAccount(Address.Zero, 1000.Ether());
_stateProvider.Commit(_spec);
_storageProvider = new StorageProvider(stateDb, _stateProvider, LimboLogs.Instance);
_virtualMachine = new VirtualMachine(_stateProvider, _storageProvider, _blockhashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance);
_environment = new ExecutionEnvironment();
_environment.ExecutingAccount = Address.Zero;
_environment.CodeSource = Address.Zero;
_environment.Originator = Address.Zero;
_environment.Sender = Address.Zero;
_environment.CodeInfo = new CodeInfo(ByteCode);
_environment.GasPrice = 0;
_environment.Value = 0;
_environment.TransferValue = 0;
_environment.CurrentBlock = _header;
_evmState = new EvmState(long.MaxValue, _environment, ExecutionType.Transaction, true, false);
}
public void Can_call_by_hash()
{
StateProvider stateProvider = CreateInitialState(null);
Keccak root = stateProvider.StateRoot;
Block block = Build.A.Block.WithParent(_blockTree.Head).WithStateRoot(root).TestObject;
BlockTreeBuilder.AddBlock(_blockTree, block);
// would need to setup state root somehow...
TransactionForRpc tx = new TransactionForRpc
{
From = TestItem.AddressA,
To = TestItem.AddressB,
GasPrice = _useNonZeroGasPrice ? 10.GWei() : 0
};
_proofModule.proof_call(tx, new BlockParameter(block.Hash));
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
string response = RpcTest.TestSerializedRequest(_proofModule, "proof_call", $"{serializer.Serialize(tx)}", $"{block.Hash}");
Assert.True(response.Contains("\"result\""));
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseSubscriberViewModel" /> class.
/// </summary>
/// <param name="stateProvider">The state provider.</param>
/// <param name="viewModelRegistry">The view model registry.</param>
public BaseSubscriberViewModel(StateProvider stateProvider, ViewModelRegistry viewModelRegistry)
: base(viewModelRegistry, stateProvider)
{
this.StateProvider = stateProvider;
this.StateProvider.Subscribe(this);
this.UpdateViewModelState(stateProvider.Current);
}
/// <summary>
/// Gets the singleton instance
/// </summary>
/// <returns></returns>
public static StateProvider Singleton()
{
if (singleton == null)
singleton = new StateProvider();
return singleton;
}
public static INdmBlockchainBridge BuildABridge()
{
MemDbProvider memDbProvider = new MemDbProvider();
StateReader stateReader = new StateReader(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
StateProvider stateProvider = new StateProvider(memDbProvider.StateDb, memDbProvider.CodeDb, LimboLogs.Instance);
IEthereumEcdsa ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
ITxPool txPool = new TxPool.TxPool(new InMemoryTxStorage(), ecdsa, MainnetSpecProvider.Instance, new TxPoolConfig(), stateProvider, LimboLogs.Instance);
BlockTree blockTree = Build.A.BlockTree().OfChainLength(1).TestObject;
IWallet wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(ecdsa, MainnetSpecProvider.Instance);
LogFinder logFinder = new LogFinder(blockTree, new InMemoryReceiptStorage(), NullBloomStorage.Instance, LimboLogs.Instance, receiptsRecovery, 1024);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(memDbProvider, false),
new ReadOnlyBlockTree(blockTree),
MainnetSpecProvider.Instance, LimboLogs.Instance);
BlockchainBridge blockchainBridge = new BlockchainBridge(
processingEnv,
txPool,
new InMemoryReceiptStorage(),
NullFilterStore.Instance,
NullFilterManager.Instance,
ecdsa,
Timestamper.Default,
logFinder,
false,
false);
WalletTxSigner txSigner = new WalletTxSigner(wallet, ChainId.Mainnet);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper.Default);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper.Default, txPool);
ITxSender txSender = new TxPoolSender(txPool, txSealer0, txSealer1);
return(new NdmBlockchainBridge(blockchainBridge, blockTree, stateReader, txSender));
}
public void Returns_empty_byte_code_for_non_existing_accounts()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
byte[] code = provider.GetCode(TestItem.AddressA);
code.Should().BeEmpty();
}
public void Prepared_block_contains_author_field()
{
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
IStateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
ITransactionProcessor transactionProcessor = Substitute.For <ITransactionProcessor>();
BlockProcessor processor = new BlockProcessor(
RinkebySpecProvider.Instance,
TestBlockValidator.AlwaysValid,
NoBlockRewards.Instance,
transactionProcessor,
stateDb,
codeDb,
stateProvider,
new StorageProvider(stateDb, stateProvider, LimboLogs.Instance),
NullTxPool.Instance,
NullReceiptStorage.Instance,
LimboLogs.Instance);
BlockHeader header = Build.A.BlockHeader.WithAuthor(TestItem.AddressD).TestObject;
Block block = Build.A.Block.WithHeader(header).TestObject;
Block[] processedBlocks = processor.Process(Keccak.EmptyTreeHash, new [] { block }, ProcessingOptions.None, NullBlockTracer.Instance);
Assert.AreEqual(1, processedBlocks.Length, "length");
Assert.AreEqual(block.Author, processedBlocks[0].Author, "author");
}
public void GlobalSetup()
{
TrieStore trieStore = new(new MemDb(), new OneLoggerLogManager(NullLogger.Instance));
IKeyValueStore codeDb = new MemDb();
_stateProvider = new StateProvider(trieStore, codeDb, new OneLoggerLogManager(NullLogger.Instance));
_stateProvider.CreateAccount(Address.Zero, 1000.Ether());
_stateProvider.Commit(_spec);
_storageProvider = new StorageProvider(trieStore, _stateProvider, new OneLoggerLogManager(NullLogger.Instance));
_worldState = new WorldState(_stateProvider, _storageProvider);
Console.WriteLine(MuirGlacier.Instance);
_virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance));
_environment = new ExecutionEnvironment
{
ExecutingAccount = Address.Zero,
CodeSource = Address.Zero,
Caller = Address.Zero,
CodeInfo = new CodeInfo(Bytecode),
Value = 0,
TransferValue = 0,
TxExecutionContext = new TxExecutionContext(_header, Address.Zero, 0)
};
_evmState = new EvmState(100_000_000L, _environment, ExecutionType.Transaction, true, _worldState.TakeSnapshot(), false);
}
public void Setup()
{
IDb blocksDb = new MemDb();
IDb blocksInfoDb = new MemDb();
IDb headersDb = new MemDb();
ChainLevelInfoRepository repository = new ChainLevelInfoRepository(blocksInfoDb);
ISpecProvider specProvider = MainNetSpecProvider.Instance;
_blockTree = new BlockTree(blocksDb, headersDb, blocksInfoDb, repository, specProvider, NullTxPool.Instance, new SyncConfig(), LimboLogs.Instance);
ISnapshotableDb stateDb = new StateDb();
ISnapshotableDb codeDb = new StateDb();
StateProvider stateProvider = new StateProvider(stateDb, codeDb, LimboLogs.Instance);
StorageProvider storageProvider = new StorageProvider(stateDb, stateProvider, LimboLogs.Instance);
BlockhashProvider blockhashProvider = new BlockhashProvider(_blockTree, LimboLogs.Instance);
VirtualMachine virtualMachine = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, LimboLogs.Instance);
TransactionProcessor transactionProcessor = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, LimboLogs.Instance);
BlockProcessor blockProcessor = new BlockProcessor(specProvider, TestBlockValidator.AlwaysValid, NoBlockRewards.Instance, transactionProcessor, stateDb, codeDb, new MemDb(), stateProvider, storageProvider, NullTxPool.Instance, NullReceiptStorage.Instance, LimboLogs.Instance);
_processor = new BlockchainProcessor(_blockTree, blockProcessor, new CompositeDataRecoveryStep(), LimboLogs.Instance, false, false);
Block genesis = Build.A.Block.Genesis.TestObject;
_blockTree.SuggestBlock(genesis);
_processor.Process(genesis, ProcessingOptions.None, NullBlockTracer.Instance);
}
public void TestInitialize()
{
var fixture = new Fixture();
factories = Substitute.For<Factories>();
navigator = Substitute.For<Navigator>();
stateProvider = Substitute.For<StateProvider>();
facade = Substitute.For<ReplacementBuilderAndSugarEstimatorFacade>();
clipboard = Substitute.For<Clipboard>();
messageDialog = Substitute.For<MessageDialog>();
navigation = new InsulinEditingViewModel.Navigation();
CreateSut();
insulin = fixture.Create<Insulin>();
insulin.InitializeCircumstances(new List<Guid>());
insulin.SetOwner(factories);
sugar = new Sugar();
sugar.SetOwner(factories);
factories.InsulinCircumstances.Returns(fixture.CreateMany<InsulinCircumstance>().ToList());
factories.CreateSugar().Returns(sugar);
settings = new Settings { MaxBolus = 5 };
factories.Settings.Returns(settings);
meal = fixture.Create<Meal>();
factories.Finder.FindMealByInsulin(insulin).Returns(meal);
factories.Finder.FindInsulinById(insulin.Id).Returns(insulin);
var replacementAndEstimatedSugars = new ReplacementAndEstimatedSugars();
replacementAndEstimatedSugars.EstimatedSugars = new List<Sugar>();
replacementAndEstimatedSugars.Replacement
= new Replacement { InsulinTotal = new Insulin(), Items = new List<ReplacementItem>() };
facade.GetReplacementAndEstimatedSugars(Arg.Any<Meal>(), Arg.Any<Insulin>(), Arg.Any<Sugar>())
.Returns(replacementAndEstimatedSugars);
factories.MealNames.Returns(new List<MealName>());
stateProvider.State.Returns(new Dictionary<string, object>());
}
public async Task <int> GetCountAsync(ActorId id, CancellationToken cancellationToken)
{
var count = await StateProvider.LoadStateAsync <int>(
id, "count", cancellationToken);
return(count);
}
public void Can_transition_between_states()
{
using (new StateProviderFixture())
{
StateProvider.Setup <ThreeValidStaticStates>();
var data = new ThreeValidStatesData();
var actor = new ThreeValidStaticStates();
actor.SetState <ThreeValidStaticStates.StateA>(data);
actor.SetState <ThreeValidStaticStates.StateB>(data);
actor.SetState <ThreeValidStaticStates.StateC>(data);
Assert.True(data.BeginStateA);
Assert.True(data.EndStateA);
Assert.True(data.BeginStateB);
Assert.True(data.EndStateB);
// last state was C
Assert.Equal(typeof(ThreeValidStaticStates.StateC), actor.CurrentState.GetType());
Assert.Equal("ThreeValidStaticStates (StateC)", actor.DisplayName);
// all states A and C have names
Assert.NotNull(actor.GetState <ThreeValidStaticStates.StateA>().Name);
Assert.NotNull(actor.GetState <ThreeValidStaticStates.StateC>().Name);
// can lookup state by name
Assert.Equal(typeof(ThreeValidStaticStates.StateA), actor.GetStateByName("StateA").GetType());
// can enumerate all states
var allStates = StateProvider.GetAllStatesByType <ThreeValidStaticStates>();
Assert.Equal(4, allStates.Count);
}
}
private static readonly Ethash Ethash = new Ethash(); // temporarily keep reusing the same one as otherwise it would recreate cache for each test
protected void Setup(ILogger logger)
{
_logger = logger;
ILogger stateLogger = ShouldLog.State ? _logger : null;
_multiDb = new MultiDb(stateLogger);
_chain = new BlockStore();
_blockhashProvider = new BlockhashProvider(_chain);
_virtualMachines = new Dictionary <EthereumNetwork, IVirtualMachine>();
_stateProviders = new Dictionary <EthereumNetwork, StateProvider>();
_storageProviders = new Dictionary <EthereumNetwork, IStorageProvider>();
_blockValidators = new Dictionary <EthereumNetwork, IBlockValidator>();
EthereumNetwork[] networks = { EthereumNetwork.Frontier, EthereumNetwork.Homestead, EthereumNetwork.Byzantium, EthereumNetwork.SpuriousDragon, EthereumNetwork.TangerineWhistle };
foreach (EthereumNetwork ethereumNetwork in networks)
{
IEthereumRelease spec = _protocolSpecificationProvider.GetSpec(ethereumNetwork, 1);
ISignatureValidator signatureValidator = new SignatureValidator(spec, ChainId.MainNet);
ITransactionValidator transactionValidator = new TransactionValidator(spec, signatureValidator);
IBlockHeaderValidator headerValidator = new BlockHeaderValidator(_chain, Ethash);
IOmmersValidator ommersValidator = new OmmersValidator(_chain, headerValidator);
IBlockValidator blockValidator = new BlockValidator(transactionValidator, headerValidator, ommersValidator, stateLogger);
_blockValidators[ethereumNetwork] = blockValidator;
_stateProviders[ethereumNetwork] = new StateProvider(new StateTree(_multiDb.CreateDb()), spec, stateLogger);
_storageProviders[ethereumNetwork] = new StorageProvider(_multiDb, _stateProviders[ethereumNetwork], stateLogger);
_virtualMachines[ethereumNetwork] = new VirtualMachine(
spec,
_stateProviders[ethereumNetwork],
_storageProviders[ethereumNetwork],
_blockhashProvider,
ShouldLog.Evm ? logger : null);
}
}
public void Empty_commit_restore()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.Commit(Frontier.Instance);
provider.Restore(-1);
}
private static void InitializeTestState(GeneralStateTest test, StateProvider stateProvider,
IStorageProvider storageProvider, ISpecProvider specProvider)
{
foreach (KeyValuePair <Address, AccountState> accountState in test.Pre)
{
foreach (KeyValuePair <UInt256, byte[]> storageItem in accountState.Value.Storage)
{
storageProvider.Set(new StorageCell(accountState.Key, storageItem.Key),
storageItem.Value.WithoutLeadingZeros().ToArray());
}
stateProvider.CreateAccount(accountState.Key, accountState.Value.Balance);
Keccak codeHash = stateProvider.UpdateCode(accountState.Value.Code);
stateProvider.UpdateCodeHash(accountState.Key, codeHash, specProvider.GenesisSpec);
stateProvider.SetNonce(accountState.Key, accountState.Value.Nonce);
}
storageProvider.Commit();
stateProvider.Commit(specProvider.GenesisSpec);
storageProvider.CommitTrees(0);
stateProvider.CommitTree(0);
storageProvider.Reset();
stateProvider.Reset();
}
public async Task <IEnumerable <int> > GetCountsAsync(CancellationToken cancellationToken)
{
ContinuationToken continuationToken = null;
var result = new List <int>();
do
{
var page = await StateProvider.GetActorsAsync(10000, continuationToken, cancellationToken);
foreach (var actorId in page.Items)
{
var state = await StateProvider.LoadStateAsync <int>(
actorId : actorId,
stateName : "count",
cancellationToken : cancellationToken);
result.Add(state);
}
continuationToken = page.ContinuationToken;
} while (continuationToken != null);
return(result);
}
public void Is_empty_account()
{
StateProvider provider = new StateProvider(new StateDb(new MemDb()), Substitute.For <IDb>(), Logger);
provider.CreateAccount(_address1, 0);
provider.Commit(Frontier.Instance);
Assert.True(provider.IsEmptyAccount(_address1));
}
private void AddCode(StateProvider stateProvider, Address account, byte[] code)
{
Keccak codeHash = stateProvider.UpdateCode(code);
stateProvider.UpdateCodeHash(account, codeHash, MuirGlacier.Instance);
stateProvider.Commit(MainnetSpecProvider.Instance.GenesisSpec, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateMonitor" /> class.
/// </summary>
/// <param name="provider">The provider to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="provider" /> is <see langword="null" />.
/// </exception>
public DelegateMonitor(StateProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
_PROVIDER = provider;
}
public void ExpectInitialStateToBeFirst()
{
var state1 = new Mock<IFlowSate>();
var state2 = new Mock<IFlowSate>();
var flowstates = new IFlowSate[] { state1.Object, state2.Object };
var factory = CreateFactory();
var provider = new StateProvider(flowstates, factory);
var result = provider.GetNext();
Assert.Equal(state1.Object, result);
}
public void ExpectNextGivenStateIfCurrentCopmpleted()
{
var state1 = new Mock<IFlowSate>();
var state2 = new Mock<IFlowSate>();
var flowstates = new IFlowSate[] { state1.Object, state2.Object };
var factory = CreateFactory();
var provider = new StateProvider(flowstates, factory);
state1.Setup(s => s.Completed).Returns(true);
var result = provider.GetNext();
Assert.Equal(state2.Object, result);
}
internal GraphParams()
{
customStateLabelProvider = null;
faStateProvider = null;
node = null;
}
public void TestInitialize()
{
factories = Substitute.For<Factories>();
factories.InsulinCircumstances.Returns(new List<InsulinCircumstance>());
factories.MealNames.Returns(new List<MealName>());
factories.Insulins.Returns(new List<Insulin>());
factories.Sugars.Returns(new List<Sugar>());
factories.Meals.Returns(new List<Meal>());
factories.Settings.Returns(new Settings());
sugarEditing = Substitute.For<SugarEditingViewModel>();
sut = new JournalViewModel(factories, new BackgroundWorkerSyncFactory(), sugarEditing);
stateProvider = Substitute.For<StateProvider>();
stateProvider.State.Returns(new Dictionary<string, object>());
sut.StateProvider = stateProvider;
navigator = Substitute.For<Navigator>();
sut.Navigator = navigator;
}
/// <summary>
/// Used internally by the derived viewer that may also set the modelprogram
/// </summary>
internal void SetStateMachine(FSM fa, StateProvider stateProvider, ModelProgram mp1, Set<Transition> groupingTransitions)
{
// Clear the node and transition tables and the cache
this.mp = mp1;
nodes.Clear();
transitions.Clear();
//reductCache.Clear();
this.faInfo = new FAInfo(this.stateViewer1.DefaultModelName, fa, stateProvider, mp1);
this.finiteAutomatonContext = new FAContext(fa, stateProvider, faInfo.ReductNames.Last, mp1);
this.finiteAutomatonContext.groupingTransitions = groupingTransitions;
//this.reductCache[this.faInfo.ReductNames.Last] = this.finiteAutomatonContext;
this.projectionButton.Text = " " + faInfo.ReductNames.Last.name.ToString();
this.projectionButton.ToolTipText = faInfo.ReductNames.Last.name.ToString();
if (faInfo.IsProduct)
{
this.projectionButton.Enabled = true;
EnableProjection();
}
else
{
this.projectionButton.Enabled = false;
}
graphChanged = true;
PerformLayout();
}
public void ExpectExceptionIfProviderHasNoMoreNextStates()
{
var state1 = new Mock<IFlowSate>();
var state2 = new Mock<IFlowSate>();
var flowstates = new IFlowSate[] { state1.Object, state2.Object };
var factory = CreateFactory();
var provider = new StateProvider(flowstates, factory);
state1.Setup(s => s.Completed).Returns(true);
state2.Setup(s => s.Completed).Returns(true);
Assert.Throws<InvalidOperationException>(() => provider.GetNext());
}
public void InvalidCardGivesException(DevelopmentCardType type)
{
var state1 = new Mock<IFlowSate>();
var state2 = new Mock<IFlowSate>();
var flowstates = new IFlowSate[] { state1.Object, state2.Object };
var factory = CreateFactory();
var provider = new StateProvider(flowstates, factory);
Assert.Throws<ArgumentException>(() => provider.Get(type));
}
public void TestGetDevelopmentCard(DevelopmentCardType cardType, Type expectedState)
{
var state1 = new Mock<IFlowSate>();
var state2 = new Mock<IFlowSate>();
var flowstates = new IFlowSate[] { state1.Object, state2.Object };
var factory = CreateFactory();
var provider = new StateProvider(flowstates, factory);
var result = provider.Get(cardType);
Assert.IsAssignableFrom(expectedState, result);
}
public void TestInitialize()
{
meal = new Meal { Id = Guid.NewGuid() };
meal.InitializeItems(new List<MealItem>());
factories = Substitute.For<Factories>();
factories.Finder.FindMealById(meal.Id).Returns(meal);
factories.MealNames.Returns(new List<MealName>());
factories.MealNames.Add(new MealName { Id = Guid.NewGuid() });
factories.DefaultEntities.MealName.Returns(new MealName { Id = Guid.NewGuid() });
trial = Substitute.For<TrialViewModel>();
backNavigation = new MealEditingViewModel.BackNavigation();
messageDialog = Substitute.For<MessageDialog>();
sut = new MealEditingViewModel(factories, new BackgroundWorkerSyncFactory(), trial, backNavigation,
new MealItemEditingViewModel(), messageDialog);
sut.Navigator = Substitute.For<Navigator>();
stateProvider = Substitute.For<StateProvider>();
sut.StateProvider = stateProvider;
sut.Init(new MealEditingViewModel.Navigation { MealIdToEdit = meal.Id });
}
/// <summary>
/// Used internally by the derived viewer that may also set the modelprogram
/// </summary>
internal void SetStateMachine(FSM fa, StateProvider stateProvider, ModelProgram mp1, Set<Transition> groupingTransitions)
{
// Clear the node and transition tables and the cache
this.mp = mp1;
// nodes.Clear(); // not needed for mp2dot, I believe
// transitions.Clear(); // ditto
//reductCache.Clear();
//this.faInfo = new FAInfo(this.stateViewer1.DefaultModelName, fa, stateProvider, mp1);
this.faInfo = new FAInfo("Fsm", fa, stateProvider, mp1); // defined in StateView.cs
this.finiteAutomatonContext = new FAContext(fa, stateProvider, faInfo.ReductNames.Last, mp1);
this.finiteAutomatonContext.groupingTransitions = groupingTransitions;
//this.reductCache[this.faInfo.ReductNames.Last] = this.finiteAutomatonContext;
// removed code here
}
// removed several members here
/// <summary>
/// View the given state machine
/// </summary>
/// <param name="fa">given finite automaton</param>
/// <param name="stateProvider">optional model program state provider</param>
public void SetStateMachine(FSM fa, StateProvider stateProvider)
{
SetStateMachine(fa, stateProvider, null, Set<Transition>.EmptySet);
}
internal FAInfo(string defaultModelName,
FSM fa, StateProvider stateProvider, ModelProgram mp)
{
this.fa = fa;
this.stateProvider = stateProvider;
this.defaultModelName = defaultModelName;
this.nameDisambiguator = new Dictionary<string, int>();
this.mp = mp;
}
internal FAContext(FSM fa, StateProvider stateProvider, ReductName reductName, ModelProgram mp)
{
this.fa = fa;
this.stateProvider = stateProvider;
this.reductName = reductName;
this.mp = mp;
this.deadNodes = FsmTraversals.GetDeadStates(fa);
this.unsafeNodes = Set<Node>.EmptySet;
this.groupingTransitions = Set<Transition>.EmptySet;
}
public void TestInitialize()
{
stateProvider = Substitute.For<StateProvider>();
stateProvider.State.Returns(new Dictionary<string, object>());
stateProvider.State[MealItemEditingViewModel.MEAL_ITEM] = "state";
}
