Пример #1
0
        private static Transaction[] GenerateTxsForRefunds(IGrouping <Address, DepositDetails> depositGroup, DevKeyStoreWallet wallet)
        {
            Console.WriteLine();
            Console.Write($"Provide nonce for {depositGroup.Key}: ");
            int nonce = int.Parse(Console.ReadLine());

            Console.Write($"Provide address to send the refund to: ");
            string  hexAddress = Console.ReadLine();
            Address refundTo   = new Address(hexAddress);

            SecureString securedPassword = ConsoleUtils.ReadSecret("Provide password: "******"Password has been accepted.");
                Console.WriteLine();
                Console.WriteLine($"Great, will generate refund transactions for deposits of {depositGroup.Key} starting with nonce {nonce}. ETH/DAI will be sent to {refundTo}.");
                List <Transaction> transactions = new List <Transaction>(depositGroup.Count());
                foreach (DepositDetails depositDetails in depositGroup)
                {
                    Deposit     deposit     = depositDetails.Deposit;
                    RefundClaim refundClaim = new RefundClaim(deposit.Id, depositDetails.DataAsset.Id, deposit.Units,
                                                              deposit.Value, deposit.ExpiryTime, depositDetails.Pepper, depositDetails.DataAsset.Provider.Address, refundTo);
                    UInt256 gasPrice = 20.GWei();

                    AbiEncoder  abiEncoder  = new AbiEncoder();
                    byte[]      txData      = abiEncoder.Encode(AbiEncodingStyle.IncludeSignature, ContractData.ClaimRefundSig, depositDetails.DataAsset.Id, refundClaim.Units, refundClaim.Value, refundClaim.ExpiryTime, refundClaim.Pepper, refundClaim.Provider, depositDetails.Consumer);
                    Transaction transaction = new Transaction();
                    transaction.Value         = 0;
                    transaction.Data          = txData;
                    transaction.To            = new Address("0xb1AD03b75bD9E5AB89968D7a37d99F9dd220796D");
                    transaction.SenderAddress = depositDetails.Consumer;
                    transaction.GasLimit      = 100000;
                    transaction.GasPrice      = gasPrice;
                    transaction.Nonce         = (UInt256)nonce++;
                    wallet.Sign(transaction, ChainId.Mainnet);

                    EthereumEcdsa ecdsa            = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
                    Address       recoveredAddress = ecdsa.RecoverAddress(transaction);
                    if (recoveredAddress != transaction.SenderAddress)
                    {
                        Console.WriteLine("Signature failure");
                        return(new Transaction[0]);
                    }

                    transactions.Add(transaction);
                }

                return(transactions.ToArray());
            }

            Console.WriteLine("Incorrect password.");
            return(new Transaction[0]);
        }
            protected override BlockProcessor CreateBlockProcessor()
            {
                AbiEncoder abiEncoder = AbiEncoder.Instance;

                ReadOnlyTransactionProcessorSource = new ReadOnlyTxProcessingEnv(
                    DbProvider,
                    new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
                    BlockTree, SpecProvider,
                    LimboLogs.Instance);
                RegisterContract  = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource);
                CertifierContract = new CertifierContract(
                    abiEncoder,
                    RegisterContract,
                    ReadOnlyTransactionProcessorSource);

                return(new AuRaBlockProcessor(
                           SpecProvider,
                           Always.Valid,
                           new RewardCalculator(SpecProvider),
                           new BlockProcessor.BlockValidationTransactionsExecutor(TxProcessor, State),
                           State,
                           Storage,
                           ReceiptStorage,
                           LimboLogs.Instance,
                           BlockTree));
            }
        protected override void InitSealEngine()
        {
            if (_context.DbProvider == null)
            {
                throw new StepDependencyException(nameof(_context.DbProvider));
            }
            if (_context.ChainSpec == null)
            {
                throw new StepDependencyException(nameof(_context.ChainSpec));
            }
            if (_context.EthereumEcdsa == null)
            {
                throw new StepDependencyException(nameof(_context.EthereumEcdsa));
            }
            if (_context.NodeKey == null)
            {
                throw new StepDependencyException(nameof(_context.NodeKey));
            }

            AbiEncoder abiEncoder = new AbiEncoder();

            _context.ValidatorStore = new ValidatorStore(_context.DbProvider.BlockInfosDb);
            IReadOnlyTransactionProcessorSource readOnlyTransactionProcessorSource = new ReadOnlyTransactionProcessorSource(_context.DbProvider, _context.BlockTree, _context.SpecProvider, _context.LogManager);
            IAuRaValidatorProcessorExtension    validatorProcessorExtension        = new AuRaValidatorProcessorFactory(_context.StateProvider, abiEncoder, _context.TransactionProcessor, readOnlyTransactionProcessorSource, _context.BlockTree, _context.ReceiptStorage, _context.ValidatorStore, _context.LogManager)
                                                                                     .CreateValidatorProcessor(_context.ChainSpec.AuRa.Validators);

            AuRaStepCalculator auRaStepCalculator = new AuRaStepCalculator(_context.ChainSpec.AuRa.StepDuration, _context.Timestamper);

            _context.SealValidator          = new AuRaSealValidator(_context.ChainSpec.AuRa, auRaStepCalculator, _context.ValidatorStore, _context.EthereumEcdsa, _context.LogManager);
            _context.RewardCalculatorSource = AuRaRewardCalculator.GetSource(_context.ChainSpec.AuRa, abiEncoder);
            _context.Sealer = new AuRaSealer(_context.BlockTree, _context.ValidatorStore, auRaStepCalculator, _context.NodeKey.Address, new BasicWallet(_context.NodeKey), new ValidSealerStrategy(), _context.LogManager);
            _context.AuRaBlockProcessorExtension = validatorProcessorExtension;
        }
Пример #4
0
        /// <summary>
        /// Calls the function in contract, state modification is allowed.
        /// </summary>
        /// <param name="header">Header in which context the call is done.</param>
        /// <param name="function">Function in contract that is being called.</param>
        /// <param name="sender">Sender of the transaction - caller of the function.</param>
        /// <param name="arguments">Arguments to the function.</param>
        /// <returns>Deserialized return value of the <see cref="function"/> based on its definition.</returns>
        protected object[] Call(BlockHeader header, AbiFunctionDescription function, Address sender, params object[] arguments)
        {
            var transaction = GenerateTransaction <SystemTransaction>(function, sender, arguments);
            var result      = Call(header, transaction);
            var objects     = AbiEncoder.Decode(function.GetReturnInfo(), result);

            return(objects);
        }
Пример #5
0
        public void Test(AbiTest abiTest)
        {
            AbiEncoder   encoder   = new AbiEncoder();
            AbiSignature signature = new AbiSignature(abiTest.Name, abiTest.Types);

            byte[] encoded = encoder.Encode(signature, abiTest.Args).Slice(4);
            Assert.True(Bytes.AreEqual(abiTest.Result, encoded));
        }
        public UInt256?BlockGasLimit(BlockHeader parentHeader)
        {
            this.BlockActivationCheck(parentHeader);
            var function = Definition.GetFunction(nameof(BlockGasLimit));
            var bytes    = Constant.CallRaw(parentHeader, function, Address.Zero);

            return((bytes?.Length ?? 0) == 0 ? (UInt256?)null : (UInt256)AbiEncoder.Decode(function.GetReturnInfo(), bytes)[0]);
        }
Пример #7
0
        /// <summary>
        /// Calls the function in contract, state modification is allowed.
        /// </summary>
        /// <param name="header">Header in which context the call is done.</param>
        /// <param name="functionName"></param>
        /// <param name="sender">Sender of the transaction - caller of the function.</param>
        /// <param name="gasLimit">Gas limit for generated transaction.</param>
        /// <param name="arguments">Arguments to the function.</param>
        /// <returns>Deserialized return value of the <see cref="functionName"/> based on its definition.</returns>
        protected object[] Call(BlockHeader header, string functionName, Address sender, long gasLimit, params object[] arguments)
        {
            var function    = AbiDefinition.GetFunction(functionName);
            var transaction = GenerateTransaction <SystemTransaction>(functionName, sender, gasLimit, header, arguments);
            var result      = Call(header, transaction);
            var objects     = AbiEncoder.Decode(function.GetReturnInfo(), result);

            return(objects);
        }
        public void SetUp()
        {
            _fileSystem = Substitute.For <IFileSystem>();
            const string expectedFilePath = "contracts/MerkleTreeSHA.bin";

            _fileSystem.File.ReadAllLinesAsync(expectedFilePath).Returns(File.ReadAllLines(expectedFilePath));
            _abiEncoder         = new AbiEncoder();
            _baselineDb         = new MemDb();
            _metadataBaselineDb = new MemDb();
        }
Пример #9
0
 protected object[] DecodeData(AbiEncodingInfo abiEncodingInfo, byte[] data)
 {
     try
     {
         return(AbiEncoder.Decode(abiEncodingInfo, data));
     }
     catch (Exception e)
     {
         throw new AbiException($"Cannot decode return data for function {abiEncodingInfo.Signature} for contract {ContractAddress}.", e);
     }
 }
Пример #10
0
        /// <summary>
        /// Same as <see cref="Call(Nethermind.Core.BlockHeader,AbiFunctionDescription,Address,object[])"/> but returns false instead of throwing <see cref="AuRaException"/>.
        /// </summary>
        /// <param name="header">Header in which context the call is done.</param>
        /// <param name="function">Function in contract that is being called.</param>
        /// <param name="sender">Sender of the transaction - caller of the function.</param>
        /// <param name="result">Deserialized return value of the <see cref="function"/> based on its definition.</param>
        /// <param name="arguments">Arguments to the function.</param>
        /// <returns>true if function was <see cref="StatusCode.Success"/> otherwise false.</returns>
        protected bool TryCall(BlockHeader header, AbiFunctionDescription function, Address sender, out object[] result, params object[] arguments)
        {
            var transaction = GenerateTransaction <SystemTransaction>(function, sender, arguments);

            if (TryCall(header, transaction, out var bytes))
            {
                result = AbiEncoder.Decode(function.GetReturnInfo(), bytes);
                return(true);
            }

            result = null;
            return(false);
        }
Пример #11
0
        /// <summary>
        /// Same as <see cref="Call(Nethermind.Core.BlockHeader,AbiFunctionDescription,Address,object[])"/> but returns false instead of throwing <see cref="AbiException"/>.
        /// </summary>
        /// <param name="header">Header in which context the call is done.</param>
        /// <param name="functionName"></param>
        /// <param name="sender">Sender of the transaction - caller of the function.</param>
        /// <param name="gasLimit">Gas limit for generated transaction.</param>
        /// <param name="result">Deserialized return value of the <see cref="functionName"/> based on its definition.</param>
        /// <param name="arguments">Arguments to the function.</param>
        /// <returns>true if function was <see cref="StatusCode.Success"/> otherwise false.</returns>
        protected bool TryCall(BlockHeader header, string functionName, Address sender, long gasLimit, out object[] result, params object[] arguments)
        {
            var function    = AbiDefinition.GetFunction(functionName);
            var transaction = GenerateTransaction <SystemTransaction>(functionName, sender, gasLimit, header, arguments);

            if (TryCall(header, transaction, out var bytes))
            {
                result = AbiEncoder.Decode(function.GetReturnInfo(), bytes);
                return(true);
            }

            result = null;
            return(false);
        }
Пример #12
0
        public INdmServices Init(NdmRequiredServices services)
        {
            AddDecoders();
            var config          = services.NdmConfig;
            var providerAddress = string.IsNullOrWhiteSpace(config.ProviderAddress)
                ? Address.Zero
                : new Address(config.ProviderAddress);
            var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
                ? Address.Zero
                : new Address(config.ConsumerAddress);
            var contractAddress = string.IsNullOrWhiteSpace(config.ContractAddress)
                ? Address.Zero
                : new Address(config.ContractAddress);

            UnlockHardcodedAccounts(providerAddress, consumerAddress, services.Wallet);

            var logManager              = services.LogManager;
            var readOnlyTree            = new ReadOnlyBlockTree(services.BlockTree);
            var readOnlyDbProvider      = new ReadOnlyDbProvider(services.RocksProvider, false);
            var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree,
                                                                      services.SpecProvider, logManager);
            var blockchainBridge = new BlockchainBridge(
                readOnlyTxProcessingEnv.StateReader,
                readOnlyTxProcessingEnv.StateProvider,
                readOnlyTxProcessingEnv.StorageProvider,
                readOnlyTxProcessingEnv.BlockTree,
                services.TransactionPool,
                services.ReceiptStorage,
                services.FilterStore,
                services.FilterManager,
                services.Wallet,
                readOnlyTxProcessingEnv.TransactionProcessor,
                services.Ecdsa);
            var dataAssetRlpDecoder = new DataAssetDecoder();
            var encoder             = new AbiEncoder();
            var depositService      = new DepositService(blockchainBridge, services.TransactionPool, encoder,
                                                         services.Wallet, contractAddress, logManager);
            var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
            var ndmDataPublisher          = services.NdmDataPublisher;
            var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();

//            ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);

            return(new Services(services, new NdmCreatedServices(consumerAddress, encoder, dataAssetRlpDecoder,
                                                                 depositService, ndmDataPublisher, jsonRpcNdmConsumerChannel, ndmConsumerChannelManager,
                                                                 blockchainBridge)));
        }
Пример #13
0
        public static IServices Init(RequiredServices services)
        {
            AddDecoders();
            var config          = services.NdmConfig;
            var providerAddress = string.IsNullOrWhiteSpace(config.ProviderAddress)
                ? Address.Zero
                : new Address(config.ProviderAddress);
            var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
                ? Address.Zero
                : new Address(config.ConsumerAddress);

            UnlockHardcodedAccounts(providerAddress, consumerAddress, services.Wallet);
            var readOnlyDbProvider = new ReadOnlyDbProvider(services.RocksProvider, false);
            var filterStore        = new FilterStore();
            var filterManager      = new FilterManager(filterStore, services.BlockProcessor, services.TransactionPool,
                                                       services.LogManager);
            var state = new RpcState(services.BlockTree, services.SpecProvider, readOnlyDbProvider,
                                     services.LogManager);
            var blockchainBridge = new BlockchainBridge(
                state.StateReader,
                state.StateProvider,
                state.StorageProvider,
                state.BlockTree,
                services.TransactionPool,
                services.TransactionPoolInfoProvider,
                services.ReceiptStorage,
                filterStore,
                filterManager,
                services.Wallet,
                state.TransactionProcessor,
                services.Ecdsa);
            var dataHeaderRlpDecoder = new DataHeaderDecoder();
            var encoder        = new AbiEncoder();
            var depositService = new DepositService(blockchainBridge, encoder, services.Wallet, config,
                                                    LimboLogs.Instance);
            var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
            var ndmDataPublisher          = services.NdmDataPublisher;
            var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();

//            ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);

            return(new Services(services, new CreatedServices(consumerAddress, encoder, dataHeaderRlpDecoder,
                                                              depositService, ndmDataPublisher, jsonRpcNdmConsumerChannel, ndmConsumerChannelManager,
                                                              blockchainBridge)));
        }
Пример #14
0
        public void Test_abi_encoding()
        {
            string text = string.Empty;

            string[] potentialLocations = new string[]
            {
                Path.Combine(TestContext.CurrentContext.TestDirectory, "basic_abi_tests.json"),
                Path.Combine(TestContext.CurrentContext.WorkDirectory, "basic_abi_tests.json"),
                Path.Combine(AppDomain.CurrentDomain.BaseDirectory ?? string.Empty, "basic_abi_tests.json"),
                Path.Combine(AppDomain.CurrentDomain.DynamicDirectory ?? string.Empty, "basic_abi_tests.json"),
            };

            foreach (string potentialLocation in potentialLocations)
            {
                try
                {
                    text = File.ReadAllText(potentialLocation);
                    break;
                }
                catch (IOException)
                {
                    TestContext.WriteLine($"Could not find test in {potentialLocation}");
                }
            }

            Dictionary <string, AbiTest> tests = JsonConvert.DeserializeObject <Dictionary <string, AbiTest> >(text);

            foreach ((string testName, AbiTest abiTest) in tests)
            {
                AbiSignature signature = new AbiSignature(
                    testName,
                    abiTest.Types.Select(t => _abiTypes[t]).ToArray());

                AbiEncoder encoder = new AbiEncoder();
                byte[]     abi     = encoder.Encode(AbiEncodingStyle.None, signature, abiTest.Args.Select(JsonToObject).ToArray());
                abi.Should().BeEquivalentTo(Bytes.FromHexString(abiTest.Result));
            }
        }
Пример #15
0
            protected override BlockProcessor CreateBlockProcessor()
            {
                AbiEncoder abiEncoder = new AbiEncoder();
                ReadOnlyTxProcessorSource readOnlyTransactionProcessorSource = new ReadOnlyTxProcessorSource(DbProvider, BlockTree, SpecProvider, LimboLogs.Instance);

                CertifierContract = new CertifierContract(
                    abiEncoder,
                    new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, readOnlyTransactionProcessorSource),
                    readOnlyTransactionProcessorSource);

                return(new AuRaBlockProcessor(
                           SpecProvider,
                           Always.Valid,
                           new RewardCalculator(SpecProvider),
                           TxProcessor,
                           StateDb,
                           CodeDb,
                           State,
                           Storage,
                           TxPool,
                           ReceiptStorage,
                           LimboLogs.Instance,
                           BlockTree));
            }
Пример #16
0
        private void InitSealEngine(IList <IAdditionalBlockProcessor> blockPreProcessors)
        {
            switch (_chainSpec.SealEngineType)
            {
            case SealEngineType.None:
                _sealer           = NullSealEngine.Instance;
                _sealValidator    = NullSealEngine.Instance;
                _rewardCalculator = NoBlockRewards.Instance;
                break;

            case SealEngineType.Clique:
                _rewardCalculator = NoBlockRewards.Instance;
                CliqueConfig cliqueConfig = new CliqueConfig();
                cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
                cliqueConfig.Epoch       = _chainSpec.Clique.Epoch;
                _snapshotManager         = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
                _sealValidator           = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
                _recoveryStep            = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
                if (_initConfig.IsMining)
                {
                    _sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
                }
                else
                {
                    _sealer = NullSealEngine.Instance;
                }

                break;

            case SealEngineType.NethDev:
                _sealer           = NullSealEngine.Instance;
                _sealValidator    = NullSealEngine.Instance;
                _rewardCalculator = NoBlockRewards.Instance;
                break;

            case SealEngineType.Ethash:
                _rewardCalculator = new RewardCalculator(_specProvider);
                var difficultyCalculator = new DifficultyCalculator(_specProvider);
                if (_initConfig.IsMining)
                {
                    _sealer = new EthashSealer(new Ethash(_logManager), _logManager);
                }
                else
                {
                    _sealer = NullSealEngine.Instance;
                }

                _sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
                break;

            case SealEngineType.AuRa:
                var abiEncoder         = new AbiEncoder();
                var validatorProcessor = new AuRaAdditionalBlockProcessorFactory(_stateProvider, abiEncoder, _transactionProcessor, _logManager)
                                         .CreateValidatorProcessor(_chainSpec.AuRa.Validators);

                _sealer           = new AuRaSealer();
                _sealValidator    = new AuRaSealValidator(validatorProcessor, _ethereumEcdsa, _logManager);
                _rewardCalculator = new AuRaRewardCalculator(_chainSpec.AuRa, abiEncoder, _transactionProcessor);
                blockPreProcessors.Add(validatorProcessor);
                break;

            default:
                throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
            }
        }
Пример #17
0
        private static async Task RunBenchmarkBlocks()
        {
            Rlp.RegisterDecoders(typeof(ParityTraceDecoder).Assembly);

            /* logging & instrumentation */
            _logManager = new NLogManager("perfTest.logs.txt", null);
            _logger     = _logManager.GetClassLogger();

            if (_logger.IsInfo)
            {
                _logger.Info("Deleting state DBs");
            }

            DeleteDb(FullStateDbPath);
            DeleteDb(FullCodeDbPath);
            DeleteDb(FullReceiptsDbPath);
            DeleteDb(FullPendingTxsDbPath);
            if (_logger.IsInfo)
            {
                _logger.Info("State DBs deleted");
            }

            /* load spec */
            ChainSpecLoader loader = new ChainSpecLoader(new EthereumJsonSerializer());
            string          path   = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"chainspec", "ropsten.json"));

            _logger.Info($"Loading ChainSpec from {path}");
            ChainSpec chainSpec = loader.Load(File.ReadAllText(path));

            _logger.Info($"ChainSpec loaded");

            var specProvider = new ChainSpecBasedSpecProvider(chainSpec);
            IRewardCalculator rewardCalculator = new RewardCalculator(specProvider);

            var dbProvider   = new RocksDbProvider(DbBasePath, DbConfig.Default, _logManager, true, true);
            var stateDb      = dbProvider.StateDb;
            var codeDb       = dbProvider.CodeDb;
            var traceDb      = dbProvider.TraceDb;
            var blocksDb     = dbProvider.BlocksDb;
            var headersDb    = dbProvider.HeadersDb;
            var blockInfosDb = dbProvider.BlockInfosDb;
            var receiptsDb   = dbProvider.ReceiptsDb;

            /* state & storage */
            var stateProvider   = new StateProvider(stateDb, codeDb, _logManager);
            var storageProvider = new StorageProvider(stateDb, stateProvider, _logManager);

            var ethereumSigner = new EthereumEcdsa(specProvider, _logManager);

            var transactionPool = new TxPool(
                NullTxStorage.Instance,
                Timestamper.Default,
                ethereumSigner,
                specProvider,
                new TxPoolConfig(),
                stateProvider,
                _logManager);

            var blockInfoRepository = new ChainLevelInfoRepository(blockInfosDb);
            var blockTree           = new UnprocessedBlockTreeWrapper(new BlockTree(blocksDb, headersDb, blockInfosDb, blockInfoRepository, specProvider, transactionPool, _logManager));
            var receiptStorage      = new InMemoryReceiptStorage();

            IBlockDataRecoveryStep recoveryStep = new TxSignaturesRecoveryStep(ethereumSigner, transactionPool, _logManager);

            /* blockchain processing */
            IList <IAdditionalBlockProcessor> blockProcessors = new List <IAdditionalBlockProcessor>();
            var blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance);
            var virtualMachine    = new VirtualMachine(stateProvider, storageProvider, blockhashProvider, specProvider, _logManager);
            var processor         = new TransactionProcessor(specProvider, stateProvider, storageProvider, virtualMachine, _logManager);

            ISealValidator sealValidator;

            if (specProvider.ChainId == RopstenSpecProvider.Instance.ChainId)
            {
                var difficultyCalculator = new DifficultyCalculator(specProvider);
                sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
            }
            else if (chainSpec.SealEngineType == SealEngineType.Clique)
            {
                var snapshotManager = new SnapshotManager(CliqueConfig.Default, blocksDb, blockTree, ethereumSigner, _logManager);
                sealValidator    = new CliqueSealValidator(CliqueConfig.Default, snapshotManager, _logManager);
                rewardCalculator = NoBlockRewards.Instance;
                recoveryStep     = new CompositeDataRecoveryStep(recoveryStep, new AuthorRecoveryStep(snapshotManager));
            }
            else if (chainSpec.SealEngineType == SealEngineType.AuRa)
            {
                var abiEncoder         = new AbiEncoder();
                var validatorProcessor = new AuRaAdditionalBlockProcessorFactory(dbProvider.StateDb, stateProvider, abiEncoder, processor, blockTree, receiptStorage, _logManager)
                                         .CreateValidatorProcessor(chainSpec.AuRa.Validators);

                sealValidator    = new AuRaSealValidator(chainSpec.AuRa, new AuRaStepCalculator(chainSpec.AuRa.StepDuration, new Timestamper()), validatorProcessor, ethereumSigner, _logManager);
                rewardCalculator = new AuRaRewardCalculator(chainSpec.AuRa, abiEncoder, processor);
                blockProcessors.Add(validatorProcessor);
            }
            else
            {
                throw new NotSupportedException();
            }

            /* store & validation */
            var headerValidator      = new HeaderValidator(blockTree, sealValidator, specProvider, _logManager);
            var ommersValidator      = new OmmersValidator(blockTree, headerValidator, _logManager);
            var transactionValidator = new TxValidator(chainSpec.ChainId);
            var blockValidator       = new BlockValidator(transactionValidator, headerValidator, ommersValidator, specProvider, _logManager);

            /* blockchain processing */
            var blockProcessor      = new BlockProcessor(specProvider, blockValidator, rewardCalculator, processor, stateDb, codeDb, traceDb, stateProvider, storageProvider, transactionPool, receiptStorage, _logManager, blockProcessors);
            var blockchainProcessor = new BlockchainProcessor(blockTree, blockProcessor, recoveryStep, _logManager, true, false);

            if (chainSpec.SealEngineType == SealEngineType.AuRa)
            {
                stateProvider.CreateAccount(Address.Zero, UInt256.Zero);
                storageProvider.Commit();
                stateProvider.Commit(Homestead.Instance);
                var finalizationManager = new AuRaBlockFinalizationManager(blockTree, blockInfoRepository, blockProcessor, blockProcessors.OfType <IAuRaValidator>().First(), _logManager);
            }

            foreach ((Address address, ChainSpecAllocation allocation) in chainSpec.Allocations)
            {
                stateProvider.CreateAccount(address, allocation.Balance);
                if (allocation.Code != null)
                {
                    Keccak codeHash = stateProvider.UpdateCode(allocation.Code);
                    stateProvider.UpdateCodeHash(address, codeHash, specProvider.GenesisSpec);
                }

                if (allocation.Constructor != null)
                {
                    Transaction constructorTransaction = new Transaction(true)
                    {
                        SenderAddress = address,
                        Init          = allocation.Constructor,
                        GasLimit      = chainSpec.Genesis.GasLimit
                    };

                    processor.Execute(constructorTransaction, chainSpec.Genesis.Header, NullTxTracer.Instance);
                }
            }

            _logger.Info($"Allocations configured, committing...");

            stateProvider.Commit(specProvider.GenesisSpec);

            _logger.Info($"Finalizing genesis...");
            chainSpec.Genesis.Header.StateRoot = stateProvider.StateRoot;
            chainSpec.Genesis.Header.Hash      = BlockHeader.CalculateHash(chainSpec.Genesis.Header);

            if (chainSpec.Genesis.Hash != blockTree.Genesis.Hash)
            {
                throw new Exception("Unexpected genesis hash");
            }

            _logger.Info($"Starting benchmark processor...");
            /* start processing */
            BigInteger totalGas  = BigInteger.Zero;
            Stopwatch  stopwatch = new Stopwatch();
            Block      currentHead;
            long       maxMemory = 0;

            blockTree.NewHeadBlock += (sender, args) =>
            {
                currentHead = args.Block;
                if (currentHead.Number == 0)
                {
                    return;
                }

                maxMemory = Math.Max(maxMemory, GC.GetTotalMemory(false));
                totalGas += currentHead.GasUsed;
                if ((BigInteger)args.Block.Number % 10000 == 9999)
                {
                    stopwatch.Stop();
                    long       ms     = 1_000L * stopwatch.ElapsedTicks / Stopwatch.Frequency;
                    BigInteger number = args.Block.Number + 1;
                    _logger.Warn($"TOTAL after {number} (ms)       : " + ms);
                    _logger.Warn($"TOTAL after {number} blocks/s   : {(decimal) currentHead.Number / (ms / 1000m),5}");
                    _logger.Warn($"TOTAL after {number} Mgas/s     : {((decimal) totalGas / 1000000) / (ms / 1000m),5}");
                    _logger.Warn($"TOTAL after {number} max mem    : {maxMemory}");
                    _logger.Warn($"TOTAL after {number} GC (0/1/2) : {GC.CollectionCount(0)}/{GC.CollectionCount(1)}/{GC.CollectionCount(2)}");
                    _logger.Warn($"Is server GC {number}           : {System.Runtime.GCSettings.IsServerGC}");
                    _logger.Warn($"GC latency mode {number}        : {System.Runtime.GCSettings.LatencyMode}");

                    _logger.Warn($"TOTAL after {number} blocks DB reads      : {Store.Metrics.BlocksDbReads}");
                    _logger.Warn($"TOTAL after {number} blocks DB writes     : {Store.Metrics.BlocksDbWrites}");
                    _logger.Warn($"TOTAL after {number} infos DB reads       : {Store.Metrics.BlockInfosDbReads}");
                    _logger.Warn($"TOTAL after {number} infos DB writes      : {Store.Metrics.BlockInfosDbWrites}");
                    _logger.Warn($"TOTAL after {number} state tree reads     : {Store.Metrics.StateTreeReads}");
                    _logger.Warn($"TOTAL after {number} state tree writes    : {Store.Metrics.StateTreeWrites}");
                    _logger.Warn($"TOTAL after {number} state DB reads       : {Store.Metrics.StateDbReads}");
                    _logger.Warn($"TOTAL after {number} state DB writes      : {Store.Metrics.StateDbWrites}");
                    _logger.Warn($"TOTAL after {number} storage tree reads   : {Store.Metrics.StorageTreeReads}");
                    _logger.Warn($"TOTAL after {number} storage tree writes  : {Store.Metrics.StorageTreeWrites}");
                    _logger.Warn($"TOTAL after {number} tree node hash       : {Store.Metrics.TreeNodeHashCalculations}");
                    _logger.Warn($"TOTAL after {number} tree node RLP decode : {Store.Metrics.TreeNodeRlpDecodings}");
                    _logger.Warn($"TOTAL after {number} tree node RLP encode : {Store.Metrics.TreeNodeRlpEncodings}");
                    _logger.Warn($"TOTAL after {number} code DB reads        : {Store.Metrics.CodeDbReads}");
                    _logger.Warn($"TOTAL after {number} code DB writes       : {Store.Metrics.CodeDbWrites}");
                    _logger.Warn($"TOTAL after {number} receipts DB reads    : {Store.Metrics.ReceiptsDbReads}");
                    _logger.Warn($"TOTAL after {number} receipts DB writes   : {Store.Metrics.ReceiptsDbWrites}");
                    _logger.Warn($"TOTAL after {number} other DB reads       : {Store.Metrics.OtherDbReads}");
                    _logger.Warn($"TOTAL after {number} other DB writes      : {Store.Metrics.OtherDbWrites}");
                    _logger.Warn($"TOTAL after {number} EVM exceptions       : {Evm.Metrics.EvmExceptions}");
                    _logger.Warn($"TOTAL after {number} SLOAD opcodes        : {Evm.Metrics.SloadOpcode}");
                    _logger.Warn($"TOTAL after {number} SSTORE opcodes       : {Evm.Metrics.SstoreOpcode}");
                    _logger.Warn($"TOTAL after {number} EXP opcodes          : {Evm.Metrics.ModExpOpcode}");
                    _logger.Warn($"TOTAL after {number} BLOCKHASH opcodes    : {Evm.Metrics.BlockhashOpcode}");
                    _logger.Warn($"TOTAL after {number} EVM calls            : {Evm.Metrics.Calls}");
                    _logger.Warn($"TOTAL after {number} RIPEMD Precompiles   : {Evm.Metrics.Ripemd160Precompile}");
                    _logger.Warn($"TOTAL after {number} SHA256 Precompiles   : {Evm.Metrics.Sha256Precompile}");
                    // disk space
                    stopwatch.Start();
                }
            };

            bool isStarted = false;

            TaskCompletionSource <object> completionSource = new TaskCompletionSource <object>();

            blockTree.NewBestSuggestedBlock += (sender, args) =>
            {
                if (!isStarted)
                {
                    blockchainProcessor.Process(blockTree.FindBlock(blockTree.Genesis.Hash, BlockTreeLookupOptions.RequireCanonical), ProcessingOptions.None, NullBlockTracer.Instance);
                    stopwatch.Start();
                    blockchainProcessor.Start();
                    isStarted = true;
                }

                if (args.Block.Number == BlocksToLoad)
                {
                    completionSource.SetResult(null);
                }
            };

            await Task.WhenAny(completionSource.Task, blockTree.LoadBlocksFromDb(CancellationToken.None, 0, 10000, BlocksToLoad));

            await blockchainProcessor.StopAsync(true).ContinueWith(
                t =>
            {
                if (t.IsFaulted)
                {
                    _logger.Error("processing failed", t.Exception);
                    _logger.Error("inner", t.Exception.InnerException);
                    Console.ReadLine();
                }

                _logger.Info("Block processing completed.");
            });

            stopwatch.Stop();
            Console.ReadLine();
        }
Пример #18
0
 /// <summary>
 /// Generates transaction.
 /// That transaction can be added to a produced block or broadcasted - if <see cref="GeneratedTransaction"/> is used as <see cref="T"/>.
 /// That transaction can be used in <see cref="CallableContract.Call(Nethermind.Core.BlockHeader,Nethermind.Core.Transaction)"/> if <see cref="SystemTransaction"/> is used as <see cref="T"/>.
 /// </summary>
 /// <param name="functionName">Function in contract that is called by the transaction.</param>
 /// <param name="sender">Sender of the transaction - caller of the function.</param>
 /// <param name="gasLimit">Gas limit for generated transaction.</param>
 /// <param name="contractAddress">address of the contract</param>
 /// <param name="arguments">Arguments to the function.</param>
 /// <typeparam name="T">Type of <see cref="Transaction"/>.</typeparam>
 /// <returns>Transaction.</returns>
 protected Transaction GenerateTransaction <T>(string functionName, Address sender, long gasLimit, Address contractAddress, params object[] arguments) where T : Transaction, new()
 => GenerateTransaction <T>(AbiEncoder.Encode(AbiDefinition.GetFunction(functionName).GetCallInfo(), arguments), sender, contractAddress, gasLimit);
Пример #19
0
        public INdmServices Init(NdmRequiredServices services)
        {
            AddDecoders();
            var config          = services.NdmConfig;
            var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
                ? Address.Zero
                : new Address(config.ConsumerAddress);
            var contractAddress = string.IsNullOrWhiteSpace(config.ContractAddress)
                ? Address.Zero
                : new Address(config.ContractAddress);

            var configId                = config.Id;
            var configManager           = services.ConfigManager;
            var logManager              = services.LogManager;
            var timestamper             = services.Timestamper;
            var wallet                  = services.Wallet;
            var readOnlyTree            = new ReadOnlyBlockTree(services.BlockTree);
            var readOnlyDbProvider      = new ReadOnlyDbProvider(services.RocksProvider, false);
            var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree,
                                                                      services.SpecProvider, logManager);
            var jsonRpcConfig    = services.ConfigProvider.GetConfig <IJsonRpcConfig>();
            var blockchainBridge = new BlockchainBridge(
                readOnlyTxProcessingEnv.StateReader,
                readOnlyTxProcessingEnv.StateProvider,
                readOnlyTxProcessingEnv.StorageProvider,
                readOnlyTxProcessingEnv.BlockTree,
                services.TransactionPool,
                services.ReceiptFinder,
                services.FilterStore,
                services.FilterManager,
                wallet,
                readOnlyTxProcessingEnv.TransactionProcessor,
                services.Ecdsa,
                services.BloomStorage,
                logManager,
                false,
                jsonRpcConfig.FindLogBlockDepthLimit);
            var dataAssetRlpDecoder = new DataAssetDecoder();
            var encoder             = new AbiEncoder();

            INdmBlockchainBridge ndmBlockchainBridge;

            if (config.ProxyEnabled)
            {
                if (config.JsonRpcUrlProxies == null || services.EthJsonRpcClientProxy == null)
                {
                    throw new InvalidDataException("JSON RPC proxy is enabled but the proxies were not initialized properly.");
                }

                services.JsonRpcClientProxy !.SetUrls(config.JsonRpcUrlProxies !);
                ndmBlockchainBridge = new NdmBlockchainBridgeProxy(services.EthJsonRpcClientProxy);
            }
            else
            {
                ndmBlockchainBridge = new NdmBlockchainBridge(blockchainBridge, services.TransactionPool);
            }

            var gasPriceService = new GasPriceService(services.HttpClient, configManager, configId, timestamper,
                                                      logManager);
            var transactionService = new TransactionService(ndmBlockchainBridge, wallet, configManager, configId,
                                                            logManager);
            var depositService            = new DepositService(ndmBlockchainBridge, encoder, wallet, contractAddress);
            var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
            var ndmDataPublisher          = services.NdmDataPublisher;
            var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel(logManager);

            if (config.JsonRpcDataChannelEnabled)
            {
                ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);
            }

            return(new Services(services, new NdmCreatedServices(consumerAddress, encoder, dataAssetRlpDecoder,
                                                                 depositService, gasPriceService, transactionService, ndmDataPublisher, jsonRpcNdmConsumerChannel,
                                                                 ndmConsumerChannelManager, ndmBlockchainBridge)));
        }
Пример #20
0
        public INdmServices Init(NdmRequiredServices services)
        {
            AddDecoders();
            var config          = services.NdmConfig;
            var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
                ? Address.Zero
                : new Address(config.ConsumerAddress);
            var contractAddress = string.IsNullOrWhiteSpace(config.ContractAddress)
                ? Address.Zero
                : new Address(config.ContractAddress);

            var configId                = config.Id;
            var configManager           = services.ConfigManager;
            var logManager              = services.LogManager;
            var timestamper             = services.Timestamper;
            var wallet                  = services.Wallet;
            var readOnlyTree            = new ReadOnlyBlockTree(services.BlockTree);
            var readOnlyDbProvider      = new ReadOnlyDbProvider(services.RocksProvider, false);
            var readOnlyTxProcessingEnv = new ReadOnlyTxProcessingEnv(readOnlyDbProvider, readOnlyTree,
                                                                      services.SpecProvider, logManager);
            var blockchainBridge = new BlockchainBridge(
                readOnlyTxProcessingEnv.StateReader,
                readOnlyTxProcessingEnv.StateProvider,
                readOnlyTxProcessingEnv.StorageProvider,
                readOnlyTxProcessingEnv.BlockTree,
                services.TransactionPool,
                services.ReceiptStorage,
                services.FilterStore,
                services.FilterManager,
                wallet,
                readOnlyTxProcessingEnv.TransactionProcessor,
                services.Ecdsa);
            var dataAssetRlpDecoder = new DataAssetDecoder();
            var encoder             = new AbiEncoder();

            INdmBlockchainBridge ndmBlockchainBridge;

            if (config.ProxyEnabled)
            {
                services.JsonRpcClientProxy.SetUrls(config.JsonRpcUrlProxies);
                ndmBlockchainBridge = new NdmBlockchainBridgeProxy(services.EthJsonRpcClientProxy);
            }
            else
            {
                ndmBlockchainBridge = new NdmBlockchainBridge(blockchainBridge, services.TransactionPool);
            }

            var gasPriceService = new GasPriceService(services.HttpClient, configManager, configId, timestamper,
                                                      logManager);
            var transactionService = new TransactionService(ndmBlockchainBridge, wallet, configManager, configId,
                                                            logManager);
            var depositService            = new DepositService(ndmBlockchainBridge, encoder, wallet, contractAddress);
            var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
            var ndmDataPublisher          = services.NdmDataPublisher;
            var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();

//            ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);

            return(new Services(services, new NdmCreatedServices(consumerAddress, encoder, dataAssetRlpDecoder,
                                                                 depositService, gasPriceService, transactionService, ndmDataPublisher, jsonRpcNdmConsumerChannel,
                                                                 ndmConsumerChannelManager, ndmBlockchainBridge)));
        }
Пример #21
0
 protected object[] DecodeData(AbiEncodingInfo abiEncodingInfo, byte[] data) => AbiEncoder.Decode(abiEncodingInfo, data);
Пример #22
0
 protected object[] DecodeReturnData(string functionName, byte[] data)
 {
     return(AbiEncoder.Decode(AbiDefinition.GetFunction(functionName).GetReturnInfo(), data));
 }
Пример #23
0
 /// <summary>
 /// Generates transaction.
 /// That transaction can be added to a produced block or broadcasted - if <see cref="GeneratedTransaction"/> is used as <see cref="T"/>.
 /// That transaction can be used in <see cref="Call(Nethermind.Core.BlockHeader,Nethermind.Core.Transaction)"/> if <see cref="SystemTransaction"/> is used as <see cref="T"/>.
 /// </summary>
 /// <param name="function">Function in contract that is called by the transaction.</param>
 /// <param name="sender">Sender of the transaction - caller of the function.</param>
 /// <param name="arguments">Arguments to the function.</param>
 /// <typeparam name="T">Type of <see cref="Transaction"/>.</typeparam>
 /// <returns>Transaction.</returns>
 protected Transaction GenerateTransaction <T>(AbiFunctionDescription function, Address sender, params object[] arguments) where T : Transaction, new()
 => GenerateTransaction <T>(AbiEncoder.Encode(function.GetCallInfo(), arguments), sender);