public async Task can_get_commits_fails_if_any_index_invalid() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; await baselineModule.baseline_track(receipt.ContractAddress); await baselineModule.baseline_insertCommit(TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH); await testRpc.AddBlock(); var result = await baselineModule.baseline_getCommits( receipt.ContractAddress, new UInt256[] { 0, (UInt256)uint.MaxValue + 1 }); await testRpc.AddBlock(); result.Result.ResultType.Should().Be(ResultType.Failure); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); }
public async Task can_return_tracked_list(uint trackedCount) { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); IStateReader stateReader = Substitute.For <IStateReader>(); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, stateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); for (int i = 0; i < trackedCount; i++) { stateReader.GetCode(null, null).ReturnsForAnyArgs(new byte[] { 255 }); await baselineModule.baseline_track(TestItem.Addresses[i]); } var result = (await baselineModule.baseline_getTracked()); result.Data.Length.Should().Be((int)trackedCount); }
public async Task insert_commits_given_hash_is_emitting_an_event(int leafCount) { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await testRpc.AddFunds(TestItem.Addresses[1], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; Keccak[] leaves = Enumerable.Repeat(TestItem.KeccakH, leafCount).ToArray(); Keccak insertLeavesTxHash = (await baselineModule.baseline_insertCommits( TestItem.Addresses[1], receipt.ContractAddress, leaves)).Data; await testRpc.AddBlock(); ReceiptForRpc insertLeafReceipt = (await testRpc.EthModule.eth_getTransactionReceipt( insertLeavesTxHash)).Data; insertLeafReceipt.Logs.Should().HaveCount(1); insertLeafReceipt.Logs[0].Data.Length.Should().Be(128 + leafCount * 32); }
public async Task can_get_commits_after_commit_is_added() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await testRpc.AddFunds(TestItem.Addresses[1], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; await baselineModule.baseline_insertCommit(TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH); await testRpc.AddBlock(); await baselineModule.baseline_track(receipt.ContractAddress); var result = await baselineModule.baseline_getCommits(receipt.ContractAddress, new UInt256[] { 0, 1 }); await testRpc.AddBlock(); result.Result.ResultType.Should().Be(ResultType.Success); result.Result.Error.Should().Be(null); result.ErrorCode.Should().Be(0); result.Data[0].Hash.Should().Be(TestItem.KeccakH); result.Data[1].Hash.Should().Be(Keccak.Zero); }
public async Task deploy_returns_an_error_when_file_is_missing() { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); var result = await baselineModule.baseline_deploy(TestItem.Addresses[0], "MissingContract"); result.Data.Should().Be(null); result.ErrorCode.Should().Be(ErrorCodes.ResourceNotFound); result.Result.Error.Should().NotBeEmpty(); result.Result.ResultType.Should().Be(ResultType.Failure); }
public async Task deploy_deploys_the_contract() { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); DepositModule depositModule = new DepositModule( testRpc.TxPoolBridge, testRpc.LogFinder, new DepositConfig() { DepositContractAddress = TestItem.AddressA.ToString() }, LimboLogs.Instance); var result = await depositModule.deposit_deploy(TestItem.Addresses[0]); result.Data.Should().NotBe(null); result.ErrorCode.Should().Be(0); result.Result.Error.Should().BeNull(); result.Result.ResultType.Should().Be(ResultType.Success); await testRpc.AddBlock(); testRpc.BlockTree.Head.Number.Should().Be(5); testRpc.BlockTree.Head.Transactions.Should().Contain(tx => tx.IsContractCreation); var code = testRpc.StateReader .GetCode(testRpc.BlockTree.Head.StateRoot, ContractAddress.From(TestItem.Addresses[0], 0)); code.Should().NotBeEmpty(); }
protected async Task Prepare() { _wallet = new DevWallet(new WalletConfig(), _logManager); _feeAccount = _wallet.GetAccounts()[0]; _consumerAccount = _wallet.GetAccounts()[1]; _providerAccount = _wallet.GetAccounts()[2]; _ndmConfig = new NdmConfig(); IReleaseSpec spec = _releaseSpec; ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99); StateDb stateDb = new StateDb(); _state = new StateProvider(stateDb, new StateDb(), _logManager); StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager); _state.CreateAccount(_consumerAccount, 1000.Ether()); _state.CreateAccount(_providerAccount, 1.Ether()); _state.Commit(spec); _state.CommitTree(); VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(), specProvider, _logManager); TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager); _bridge = new BlockchainBridge(processor); TxReceipt receipt = await DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount))); ((NdmConfig)_ndmConfig).ContractAddress = receipt.ContractAddress.ToString(); _contractAddress = receipt.ContractAddress; _txPool = new TxPool.TxPool(new InMemoryTxStorage(), Timestamper.Default, new EthereumEcdsa(specProvider.ChainId, _logManager), specProvider, new TxPoolConfig(), _state, _logManager); _ndmBridge = new NdmBlockchainBridge(_bridge, _bridge, _bridge, _bridge); }
public async Task deploy_deploys_the_contract() { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); var result = await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA"); result.Data.Should().NotBe(null); result.ErrorCode.Should().Be(0); result.Result.Error.Should().BeNull(); result.Result.ResultType.Should().Be(ResultType.Success); await testRpc.AddBlock(); testRpc.BlockTree.Head.Number.Should().Be(5); testRpc.BlockTree.Head.Transactions.Should().Contain(tx => tx.IsContractCreation); var code = testRpc.StateReader .GetCode(testRpc.BlockTree.Head.StateRoot, ContractAddress.From(TestItem.Addresses[0], 0)); code.Should().NotBeEmpty(); }
public async Task can_restore_tracking_list_on_startup(uint trackedCount) { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); MemDb memDb = new MemDb(); BaselineModule baselineModule = new BaselineModule( testRpc.TxPoolBridge, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, memDb, LimboLogs.Instance); for (int i = 0; i < trackedCount; i++) { await baselineModule.baseline_track(TestItem.Addresses[i]); // any address (no need for tree there) } BaselineModule restored = new BaselineModule( testRpc.TxPoolBridge, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, memDb, LimboLogs.Instance); var resultRestored = await restored.baseline_getTracked(); resultRestored.Data.Length.Should().Be((int)trackedCount); }
public async Task Process_long_running_branch(int blocksAmount) { var address = TestItem.Addresses[0]; var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); var testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev) .Build(spec); testRpc.TestWallet.UnlockAccount(address, new SecureString()); await testRpc.AddFunds(address, 1.Ether()); await testRpc.AddBlock(); var suggestedBlockResetEvent = new SemaphoreSlim(0); testRpc.BlockTree.NewHeadBlock += (s, e) => { suggestedBlockResetEvent.Release(1); }; var branchLength = blocksAmount + (int)testRpc.BlockTree.BestKnownNumber + 1; ((BlockTree)testRpc.BlockTree).AddBranch(branchLength, (int)testRpc.BlockTree.BestKnownNumber); (await suggestedBlockResetEvent.WaitAsync(TestBlockchain.DefaultTimeout * 10)).Should().BeTrue(); Assert.AreEqual(branchLength - 1, (int)testRpc.BlockTree.BestKnownNumber); }
public async Task can_get_leaves_fails_if_any_index_invalid() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = new BaselineModule( testRpc.TxPoolBridge, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; await baselineModule.baseline_track(receipt.ContractAddress); await baselineModule.baseline_insertLeaf(TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH); await testRpc.AddBlock(); var result = await baselineModule.baseline_getLeaves(receipt.ContractAddress, 0, (UInt256)uint.MaxValue + 1); await testRpc.AddBlock(); result.Result.ResultType.Should().Be(ResultType.Failure); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); }
public async Task can_get_siblings_is_protected_against_overflow(long leafIndex) { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; await baselineModule.baseline_insertLeaf(TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH); await testRpc.AddBlock(); var result = await baselineModule.baseline_getSiblings(receipt.ContractAddress, leafIndex); await testRpc.AddBlock(); result.Result.ResultType.Should().Be(ResultType.Failure); result.Result.Error.Should().NotBeNull(); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); result.Data.Should().BeNull(); }
public async Task deploy_bytecode_deploys_the_contract() { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); using TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest <BaseLineRpcBlockchain>(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); BaselineModule baselineModule = CreateBaselineModule(testRpc); var result = await baselineModule.baseline_deployBytecode( TestItem.Addresses[0], File.ReadAllText("testBytecode")); result.Data.Should().NotBe(null); result.ErrorCode.Should().Be(0); result.Result.Error.Should().BeNull(); result.Result.ResultType.Should().Be(ResultType.Success); await testRpc.AddBlock(); testRpc.BlockTree.Head.Number.Should().Be(2); testRpc.BlockTree.Head.Transactions.Should().Contain(tx => tx.IsContractCreation); var code = testRpc.StateReader .GetCode(testRpc.BlockTree.Head.StateRoot, ContractAddress.From(TestItem.Addresses[0], 0)); code.Should().NotBeEmpty(); }
public async Task second_track_request_will_fail() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await baselineModule.baseline_track(TestItem.AddressC); var result = await baselineModule.baseline_track(TestItem.AddressC); result.Result.ResultType.Should().Be(ResultType.Failure); result.Result.Error.Should().NotBeNull(); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); }
private async Task <(TestRpcBlockchain TestRpc, BaselineModule BaselineModule)> InitializeTestRpc(Address address) { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); var blockBuilder = Core.Test.Builders.Build.A.Block.Genesis.WithGasLimit(10000000000); var testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev) .WithGenesisBlockBuilder(blockBuilder) .Build(spec); testRpc.TestWallet.UnlockAccount(address, new SecureString()); await testRpc.AddFunds(address, 1.Ether()); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, new AbiEncoder(), _fileSystem, _baselineDb, _metadataBaselineDb, LimboLogs.Instance, testRpc.BlockProcessor, new DisposableStack()); Keccak txHash = (await baselineModule.baseline_deploy(address, "MerkleTreeSHA")).Data; await testRpc.AddBlock(); return(testRpc, baselineModule); }
public async Task track_untrack_track_works() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); Address treeAddress = await Deploy(testRpc, baselineModule); var result = await baselineModule.baseline_track(treeAddress); result.Result.ResultType.Should().Be(ResultType.Success); result = await baselineModule.baseline_untrack(treeAddress); result.Result.ResultType.Should().Be(ResultType.Success); result = await baselineModule.baseline_track(treeAddress); result.Result.ResultType.Should().Be(ResultType.Success); var countResult = await baselineModule.baseline_getCount(treeAddress); countResult.Result.ResultType.Should().Be(ResultType.Success); }
public async Task deploy_bytecode_validates_input(string bytecode) { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); BaselineModule baselineModule = CreateBaselineModule(testRpc); var result = await baselineModule.baseline_deployBytecode( TestItem.Addresses[0], bytecode); // invalid input result.Data.Should().Be(null); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); result.Result.Error.Should().NotBeNull(); result.Result.ResultType.Should().Be(ResultType.Failure); await testRpc.AddBlock(); testRpc.BlockTree.Head.Number.Should().Be(5); testRpc.BlockTree.Head.Transactions.Should().NotContain(tx => tx.IsContractCreation); var code = testRpc.StateReader .GetCode(testRpc.BlockTree.Head.StateRoot, ContractAddress.From(TestItem.Addresses[0], 0)); code.Should().BeEmpty(); }
public async Task insert_leaf_given_hash_is_emitting_an_event() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await testRpc.AddFunds(TestItem.Addresses[1], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; Keccak insertLeafTxHash = ( await baselineModule.baseline_insertLeaf( TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH)).Data; await testRpc.AddBlock(); ReceiptForRpc insertLeafReceipt = (await testRpc.EthModule.eth_getTransactionReceipt(insertLeafTxHash)).Data; insertLeafReceipt.Logs.Should().HaveCount(1); }
public async Task insert_commit_given_hash_is_emitting_an_event() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); BaselineTree baselineTree = new ShaBaselineTree(new MemDb(), new MemDb(), new byte[] { }, 0, LimboNoErrorLogger.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await testRpc.AddFunds(TestItem.Addresses[1], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; Keccak insertLeafTxHash = ( await baselineModule.baseline_insertCommit( TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH)).Data; await testRpc.AddBlock(); ReceiptForRpc insertLeafReceipt = (await testRpc.EthModule.eth_getTransactionReceipt(insertLeafTxHash)).Data; insertLeafReceipt.Logs.Should().HaveCount(1); }
protected void Prepare() { _wallet = new DevWallet(new WalletConfig(), _logManager); _feeAccount = _wallet.GetAccounts()[0]; _consumerAccount = _wallet.GetAccounts()[1]; _providerAccount = _wallet.GetAccounts()[2]; _ndmConfig = new NdmConfig(); IReleaseSpec spec = _releaseSpec; ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99); StateDb stateDb = new StateDb(); _state = new StateProvider(stateDb, new StateDb(), _logManager); StorageProvider storageProvider = new StorageProvider(stateDb, _state, _logManager); _state.CreateAccount(_consumerAccount, 1000.Ether()); _state.CreateAccount(_providerAccount, 1.Ether()); _state.Commit(spec); _state.CommitTree(); VirtualMachine machine = new VirtualMachine(_state, storageProvider, Substitute.For <IBlockhashProvider>(), _logManager); TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager); _bridge = new BlockchainBridge(processor, _releaseSpec); TxReceipt receipt = DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount))); _ndmConfig.ContractAddress = receipt.ContractAddress.ToString(); }
public async Task concurrent_track_requests_will_succeed() { Random random = new Random(42); SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); IStateReader stateReader = Substitute.For <IStateReader>(); BaselineModule baselineModule = CreateBaselineModule(testRpc, stateReader); int iterationsPerTask = 1000; Action trackAction = () => { for (int i = 0; i < iterationsPerTask; i++) { byte[] bytes = new byte[20]; random.NextBytes(bytes); Address address = new Address(bytes); stateReader.GetCode(Arg.Any <Keccak>(), address).Returns(new byte[] { 255 }); var result = baselineModule.baseline_track(address).Result; // safe to invoke Result here result.Result.ResultType.Should().Be(ResultType.Success); } }; Task task1 = new Task(trackAction); Task task2 = new Task(trackAction); Task task3 = new Task(trackAction); task1.Start(); task2.Start(); task3.Start(); await Task.WhenAll(task1, task2, task3); }
public async Task Parallel_calls() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest( SealEngineType.NethDev).Build(spec, 100000.Ether()); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); for (int i = 0; i < 255; i++) { testRpc.TestWallet.UnlockAccount(TestItem.Addresses[i], new SecureString()); await testRpc.AddFunds(TestItem.Addresses[i], 100.Ether()); } // Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; // await testRpc.AddBlock(); // ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; List <Task> tasks = new List <Task>(); for (int i = 0; i < 16; i++) { Task task = RunAll(testRpc, baselineModule, i); tasks.Add(task); } await Task.WhenAny(Task.Delay(30000), Task.WhenAny(tasks)).ContinueWith(t => { foreach (Task task in tasks) { if (task.IsFaulted) { ExceptionHelper.Rethrow(task.Exception !.InnerException); } } }); await Task.WhenAny(Task.Delay(30000), Task.WhenAll(tasks)).ContinueWith(t => { foreach (Task task in tasks) { if (task.IsFaulted) { ExceptionHelper.Rethrow(task.Exception !.InnerException); } } }); }
private async Task <TestRpcBlockchain> CreateTestRpc() { Address address = TestItem.Addresses[0]; SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev) .Build(spec); testRpc.TestWallet.UnlockAccount(address, new SecureString()); await testRpc.AddFunds(address, 1.Ether()); return(testRpc); }
public async Task untrack_fails_when_not_tracked() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); var result = await baselineModule.baseline_untrack(TestItem.AddressC); result.Result.ResultType.Should().Be(ResultType.Failure); }
public async Task can_get_siblings_after_leaf_is_added() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, testRpc.StateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, new MemDb(), LimboLogs.Instance); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); await testRpc.AddFunds(TestItem.Addresses[1], 1.Ether()); Keccak txHash = (await baselineModule.baseline_deploy(TestItem.Addresses[0], "MerkleTreeSHA")).Data; await testRpc.AddBlock(); ReceiptForRpc receipt = (await testRpc.EthModule.eth_getTransactionReceipt(txHash)).Data; await baselineModule.baseline_insertLeaf( TestItem.Addresses[1], receipt.ContractAddress, TestItem.KeccakH); await testRpc.AddBlock(); await baselineModule.baseline_track(receipt.ContractAddress); var result = await baselineModule.baseline_getSiblings(receipt.ContractAddress, 0); await testRpc.AddBlock(); result.Result.ResultType.Should().Be(ResultType.Success); result.Result.Error.Should().Be(null); result.ErrorCode.Should().Be(0); result.Data.Should().HaveCount(32); Keccak root = (await baselineModule.baseline_getRoot(receipt.ContractAddress)).Data; bool verificationResult = (await baselineModule.baseline_verify( receipt.ContractAddress, root, TestItem.KeccakH, result.Data)) .Data; verificationResult.Should().Be(true); }
public async Task track_request_will_succeed() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); IStateReader stateReader = Substitute.For <IStateReader>(); BaselineModule baselineModule = CreateBaselineModule(testRpc, stateReader); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); stateReader.GetCode(Arg.Any <Keccak>(), TestItem.AddressC).Returns(new byte[] { 255 }); var result = await baselineModule.baseline_track(TestItem.AddressC); result.Result.ResultType.Should().Be(ResultType.Success); }
public async Task track_on_an_empty_code_account_will_fail() { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); BaselineModule baselineModule = CreateBaselineModule(testRpc); await testRpc.AddFunds(TestItem.Addresses[0], 1.Ether()); var result = await baselineModule.baseline_track(TestItem.AddressC); result.Result.ResultType.Should().Be(ResultType.Failure); result.Result.Error.Should().NotBeNull(); result.ErrorCode.Should().Be(ErrorCodes.InvalidInput); }
protected async Task Prepare() { _wallet = new DevWallet(new WalletConfig(), _logManager); _feeAccount = _wallet.GetAccounts()[0]; _consumerAccount = _wallet.GetAccounts()[1]; _providerAccount = _wallet.GetAccounts()[2]; _ndmConfig = new NdmConfig(); IReleaseSpec spec = _releaseSpec; ISpecProvider specProvider = new SingleReleaseSpecProvider(spec, 99); MemDb stateDb = new MemDb(); TrieStore trieStore = new TrieStore(stateDb, _logManager); _state = new StateProvider(trieStore, new MemDb(), _logManager); StorageProvider storageProvider = new StorageProvider(trieStore, _state, _logManager); _state.CreateAccount(_consumerAccount, 1000.Ether()); _state.CreateAccount(_providerAccount, 1.Ether()); _state.Commit(spec); _state.CommitTree(0); VirtualMachine machine = new VirtualMachine(Substitute.For <IBlockhashProvider>(), specProvider, _logManager); TransactionProcessor processor = new TransactionProcessor(specProvider, _state, storageProvider, machine, _logManager); _bridge = new BlockchainBridge(processor); TxReceipt receipt = await DeployContract(Bytes.FromHexString(ContractData.GetInitCode(_feeAccount))); ((NdmConfig)_ndmConfig).ContractAddress = receipt.ContractAddress.ToString(); _contractAddress = receipt.ContractAddress; IBlockTree blockTree = Substitute.For <IBlockTree>(); Block block = Build.A.Block.WithNumber(0).TestObject; blockTree.Head.Returns(block); TransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree); _txPool = new TxPool.TxPool( new EthereumEcdsa(specProvider.ChainId, _logManager), new ChainHeadInfoProvider(specProvider, blockTree, _state), new TxPoolConfig(), new TxValidator(specProvider.ChainId), _logManager, transactionComparerProvider.GetDefaultComparer()); _ndmBridge = new NdmBlockchainBridge(_bridge, _bridge, _bridge, _bridge); }
public async Task deploy_returns_an_error_when_file_is_missing() { var spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); using TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest <BaseLineRpcBlockchain>(SealEngineType.NethDev).Build(spec); testRpc.TestWallet.UnlockAccount(TestItem.Addresses[0], new SecureString()); BaselineModule baselineModule = CreateBaselineModule(testRpc); var result = await baselineModule.baseline_deploy(TestItem.Addresses[0], "MissingContract"); result.Data.Should().Be(null); result.ErrorCode.Should().Be(ErrorCodes.ResourceNotFound); result.Result.Error.Should().NotBeEmpty(); result.Result.ResultType.Should().Be(ResultType.Failure); }
public async Task can_restore_tracking_list_on_startup(uint trackedCount) { SingleReleaseSpecProvider spec = new SingleReleaseSpecProvider(ConstantinopleFix.Instance, 1); TestRpcBlockchain testRpc = await TestRpcBlockchain.ForTest(SealEngineType.NethDev).Build(spec); MemDb memDb = new MemDb(); MemDb baselineMetaDataDb = new MemDb(); IStateReader stateReader = Substitute.For <IStateReader>(); BaselineModule baselineModule = new BaselineModule( testRpc.TxSender, stateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, memDb, baselineMetaDataDb, LimboLogs.Instance, testRpc.BlockProcessor, new DisposableStack()); for (int i = 0; i < trackedCount; i++) { stateReader.GetCode(null, null).ReturnsForAnyArgs(new byte[] { 255 }); await baselineModule.baseline_track(TestItem.Addresses[i]); // any address (no need for tree there) } BaselineModule restored = new BaselineModule( testRpc.TxSender, stateReader, testRpc.LogFinder, testRpc.BlockTree, _abiEncoder, _fileSystem, memDb, baselineMetaDataDb, LimboLogs.Instance, testRpc.BlockProcessor, new DisposableStack()); var resultRestored = await restored.baseline_getTracked(); resultRestored.Data.Length.Should().Be((int)trackedCount); }