conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
using AElf.Kernel.Managers;
=======
>>>>>>>
<<<<<<<
private readonly IBinaryMerkleTreeManager _binaryMerkleTreeManager;
=======
>>>>>>>
private readonly IBinaryMerkleTreeManager _binaryMerkleTreeManager; |
<<<<<<<
if(!chainContext.StateCache.TryGetValue(path, out var byteArray))
throw new SmartContractFindRegistrationException("failed to find registration from zero contract");
=======
if(chainContext.StateCache == null || !chainContext.StateCache.TryGetValue(path, out var byteArray))
throw new InvalidOperationException("failed to find registration from zero contract");
>>>>>>>
if(chainContext.StateCache == null || !chainContext.StateCache.TryGetValue(path, out var byteArray))
throw new SmartContractFindRegistrationException("failed to find registration from zero contract"); |
<<<<<<<
var blockValidationResult = await _blockValidationService.ValidateBlockAsync(block, await GetChainContextAsync());
Logger.LogInformation($"Block validation result {block} - {blockValidationResult}");
=======
var blockValidationResult = await _blockValidationService.ValidateBlockAsync(block);
_logger?.Info($"Block validation result {block} - {blockValidationResult}");
>>>>>>>
var blockValidationResult = await _blockValidationService.ValidateBlockAsync(block);
Logger.LogInformation($"Block validation result {block} - {blockValidationResult}");
<<<<<<<
Logger.LogTrace($"Execution result of block {block} - {executionResult}");
if (executionResult.CanExecuteAgain())
=======
_logger?.Trace($"Execution result of block {block} - {executionResult}");
if (executionResult == BlockExecutionResult.AlreadyAppended)
{
// good to go
}
else if (executionResult.CanExecuteAgain())
>>>>>>>
Logger.LogTrace($"Execution result of block {block} - {executionResult}");
if (executionResult == BlockExecutionResult.AlreadyAppended)
{
// good to go
}
else if (executionResult.CanExecuteAgain()) |
<<<<<<<
=======
using NLog;
>>>>>>>
<<<<<<<
public byte[] SmartContractZeroCode
{
get
{
byte[] code = File.ReadAllBytes(Path.GetFullPath(Path.GetFullPath(Path.Combine(_options.DllDir, _options.ZeroContractDll))));
return code;
}
}
=======
public byte[] SmartContractZeroCode => File.ReadAllBytes(Path.GetFullPath(Path.Combine(_options.DllDir, _options.ZeroContractDll)));
>>>>>>>
public byte[] SmartContractZeroCode
{
get
{
byte[] code = File.ReadAllBytes(Path.GetFullPath(Path.GetFullPath(Path.Combine(_options.DllDir, _options.ZeroContractDll))));
return code;
}
}
<<<<<<<
byte[] code = File.ReadAllBytes(Path.GetFullPath(options.DllDir + "/" + options.ContractDll));
=======
var code = File.ReadAllBytes(Path.GetFullPath(options.DllDir + "/" + options.ContractDll));
>>>>>>>
var code = File.ReadAllBytes(Path.GetFullPath(options.DllDir + "/" + options.ContractDll));
<<<<<<<
/*Logger.LogInformation("Benchmark report \n \t Configuration: \n" +
string.Join("\n", _options.Select(option => string.Format("\t {0} - {1}", option.Key, option.Value))) +
"\n\n\n\t Benchmark result:\n" + string.Join("\n", resDict.Select(kv=> "\t" + kv.Key + ": " + kv.Value)));*/
=======
_logger.Info("Benchmark report \n \t Configuration: \n" + _options +
"\n\n\n\t Benchmark result:\n" + string.Join("\n", resDict.Select(kv=> "\t" + kv.Key + ": " + kv.Value)));
>>>>>>>
Logger.LogInformation("Benchmark report \n \t Configuration: \n" + _options +
"\n\n\n\t Benchmark result:\n" + string.Join("\n", resDict.Select(kv=> "\t" + kv.Key + ": " + kv.Value))); |
<<<<<<<
using System;
using System.Threading.Tasks;
=======
using System.Threading.Tasks;
>>>>>>>
using System.Threading.Tasks;
<<<<<<<
public PoTC(ILogger logger,
IMiner miner,
ITxPoolService txPoolService,
IP2P p2p)
=======
public PoTC(IMiner miner, ITxPoolService txPoolService)
>>>>>>>
public PoTC(IMiner miner, ITxPoolService txPoolService) |
<<<<<<<
private readonly Func<List<Transaction>, ILogger, List<Transaction>> _generatedByMeCrossChain =
(list, logger) =>
{
var toRemove = new List<Transaction>();
toRemove.AddRange(list.FindAll(tx => tx.From != Address.LoadHex(NodeConfig.Instance.NodeAccount)));
return toRemove.Where(t => t.Type == TransactionType.CrossChainBlockInfoTransaction).ToList();
};
=======
private readonly Func<List<Transaction>, ILogger, List<Transaction>> _firstCrossChainTxnGeneratedByMe = (list, logger) =>
{
var toRemove = new List<Transaction>();
var crossChainTxns = list.FindAll(tx =>
tx.Type == TransactionType.CrossChainBlockInfoTransaction &&
tx.From == Address.LoadHex(NodeConfig.Instance.NodeAccount)).ToList();
if (crossChainTxns.Count <= 1)
return toRemove;
// sort txns with timestamp
crossChainTxns.Sort((t1, t2) => IsFirst(t1, t2));
var firstTxn = crossChainTxns.FirstOrDefault();
// only reserve first txn
if(firstTxn != null)
toRemove.AddRange(list.FindAll(t => !t.Equals(firstTxn)));
return toRemove;
};
>>>>>>>
private readonly Func<List<Transaction>, ILogger, List<Transaction>> _firstCrossChainTxnGeneratedByMe = (list, logger) =>
{
var toRemove = new List<Transaction>();
var crossChainTxns = list.FindAll(tx =>
tx.Type == TransactionType.CrossChainBlockInfoTransaction &&
tx.From == Address.LoadHex(NodeConfig.Instance.NodeAccount)).ToList();
if (crossChainTxns.Count <= 1)
return toRemove;
// sort txns with timestamp
crossChainTxns.Sort((t1, t2) => IsFirst(t1, t2));
var firstTxn = crossChainTxns.FirstOrDefault();
// only reserve first txn
if(firstTxn != null)
toRemove.AddRange(list.FindAll(t => !t.Equals(firstTxn)));
return toRemove;
};
<<<<<<<
_logger?.Trace(
$"Consensus state changed to {inState.ConsensusBehavior.ToString()}, " +
"will reset dpos tx filter.");
switch (inState.ConsensusBehavior)
{
case ConsensusBehavior.InitializeAElfDPoS:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _oneInitialTx;
break;
case ConsensusBehavior.PublishOutValueAndSignature:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _onePublishOutValueTx;
break;
case ConsensusBehavior.UpdateAElfDPoS:
_txFilter = null;
_txFilter += _oneUpdateAElfDPoSTx;
_txFilter += _generatedByMeCrossChain;
break;
}
=======
case ConsensusBehavior.InitializeAElfDPoS:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _oneInitialTx;
break;
case ConsensusBehavior.PublishOutValueAndSignature:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _onePublishOutValueTx;
break;
case ConsensusBehavior.UpdateAElfDPoS:
_txFilter = null;
_txFilter += _oneUpdateAElfDPoSTx;
break;
>>>>>>>
_logger?.Trace(
$"Consensus state changed to {inState.ConsensusBehavior.ToString()}, " +
"will reset dpos tx filter.");
switch (inState.ConsensusBehavior)
{
case ConsensusBehavior.InitializeAElfDPoS:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _oneInitialTx;
break;
case ConsensusBehavior.PublishOutValueAndSignature:
_txFilter = null;
_txFilter += _generatedByMe;
_txFilter += _onePublishOutValueTx;
break;
case ConsensusBehavior.UpdateAElfDPoS:
_txFilter = null;
_txFilter += _oneUpdateAElfDPoSTx;
break;
} |
<<<<<<<
protected Block(IHash<IBlock> preBlockHash)
=======
public Block(Hash preBlockHash)
>>>>>>>
protected Block(Hash preBlockHash) |
<<<<<<<
await ApproveBalanceAsync(lockedTokenAmount);
var otherChainId = ChainHelpers.GetChainId(5);
=======
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty);
var requestTxResult =await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContractContainer.CrossChainContractStub.RequestChainCreation),
sideChainCreationRequest);
var chainId = RequestChainCreationOutput.Parser.ParseFrom(requestTxResult.ReturnValue).ChainId;
var otherChainId = ChainHelper.GetChainId(5);
>>>>>>>
await ApproveBalanceAsync(lockedTokenAmount);
var otherChainId = ChainHelper.GetChainId(5);
<<<<<<<
var sideChainId2 = ChainHelpers.GetChainId(2);
=======
var tx1 = await GenerateTransactionAsync(CrossChainContractAddress,
nameof(CrossChainContractContainer.CrossChainContractStub.RequestChainCreation), null, sideChainCreationRequest);
await MineAsync(new List<Transaction> {tx1});
var sideChainId2 = ChainHelper.GetChainId(2);
>>>>>>>
var sideChainId2 = ChainHelper.GetChainId(2); |
<<<<<<<
using Google.Protobuf.WellKnownTypes;
=======
using Microsoft.Extensions.DependencyInjection;
>>>>>>>
using Google.Protobuf.WellKnownTypes;
using Microsoft.Extensions.DependencyInjection; |
<<<<<<<
private const int VotersCount = 2;
=======
private const int VotersCount = 10;
>>>>>>>
private const int VotersCount = 10;
<<<<<<<
public DividendsTest(MockSetup mock)
=======
public DividendsTest(MockSetup mock, SimpleExecutingService simpleExecutingService)
>>>>>>>
public DividendsTest()
<<<<<<<
InitialCandidates();
InitialVoters();
=======
}
[Fact]
//[Fact(Skip = "Time consuming.")]
public void ReceiveDividendsTest()
{
GlobalConfig.ElfTokenPerBlock = 1000;
DividendsInitializationTest();
InitializeCandidates();
InitializeVoters();
var history0 = _contracts.GetCandidatesHistoryInfo();
>>>>>>>
}
[Fact]
//[Fact(Skip = "Time consuming.")]
public void ReceiveDividendsTest()
{
GlobalConfig.ElfTokenPerBlock = 1000;
DividendsInitializationTest();
InitializeCandidates();
InitializeVoters();
var history0 = _contracts.GetCandidatesHistoryInfo();
<<<<<<<
=======
>>>>>>>
<<<<<<<
=======
>>>>>>>
<<<<<<<
=======
var availableDividends = _contracts.GetAllAvailableDividends(mustVotedVoter.PublicKey.ToHex());
>>>>>>>
var availableDividends = _contracts.GetAllAvailableDividends(mustVotedVoter.PublicKey.ToHex());
<<<<<<<
private void InitialMiners()
=======
private void InitializeMiners()
>>>>>>>
private void InitializeMiners()
<<<<<<<
private void InitialTerm(ECKeyPair starterKeyPair)
=======
private void InitializeTerm(ECKeyPair starterKeyPair)
>>>>>>>
private void InitializeTerm(ECKeyPair starterKeyPair)
<<<<<<<
new Miners {PublicKeys = {_initialMiners.Select(m => m.PublicKey.ToHex())}}.GenerateNewTerm(
MiningInterval);
=======
new Miners {PublicKeys = {_initialMiners.Select(m => m.PublicKey.ToHex())}}.GenerateNewTerm(
MiningInterval, 0);
>>>>>>>
new Miners {PublicKeys = {_initialMiners.Select(m => m.PublicKey.ToHex())}}.GenerateNewTerm(
MiningInterval, 0); |
<<<<<<<
Task RemovePeerAsync(string pubkey);
=======
void RemovePeer(string pubkey);
Task<bool> CheckEndpointAvailableAsync(DnsEndPoint endpoint);
>>>>>>>
Task<bool> CheckEndpointAvailableAsync(DnsEndPoint endpoint);
Task RemovePeerAsync(string pubkey); |
<<<<<<<
block = _kernelTestHelper.GenerateBlock(9, Hash.FromString("test"), null,
new Dictionary<string, ByteString>
{{ConsensusConstants.ConsensusExtraDataKey, ByteString.CopyFromUtf8("extra data")}});
=======
block = _kernelTestHelper.GenerateBlock(9, HashHelper.ComputeFromString("test"), null, ByteString.CopyFromUtf8("extra data"));
>>>>>>>
block = _kernelTestHelper.GenerateBlock(9, HashHelper.ComputeFromString("test"), null,
new Dictionary<string, ByteString>
{{ConsensusConstants.ConsensusExtraDataKey, ByteString.CopyFromUtf8("extra data")}});
<<<<<<<
block = _kernelTestHelper.GenerateBlock(9, Hash.FromString("test"), null,
new Dictionary<string, ByteString>
{{ConsensusConstants.ConsensusExtraDataKey, ByteString.CopyFromUtf8("extra data")}});
=======
block = _kernelTestHelper.GenerateBlock(9, HashHelper.ComputeFromString("test"), null, ByteString.CopyFromUtf8("extra data"));
>>>>>>>
block = _kernelTestHelper.GenerateBlock(9, HashHelper.ComputeFromString("test"), null,
new Dictionary<string, ByteString>
{{ConsensusConstants.ConsensusExtraDataKey, ByteString.CopyFromUtf8("extra data")}}); |
<<<<<<<
Linker.Link(LinkType.AbsoluteAddress, PatchType.I4, multibootHeader, (int)stream.Position, Linker.EntryPoint, 0);
=======
Linker.Link(LinkType.AbsoluteAddress, PatchType.I4, multibootHeader, (int)stream.Position, 0, entryPoint, 0);
>>>>>>>
Linker.Link(LinkType.AbsoluteAddress, PatchType.I4, multibootHeader, (int)stream.Position, entryPoint, 0); |
<<<<<<<
private const int GetNodesTimeout = 500;
=======
private const int UpdateHandshakeTimeout = 400;
>>>>>>>
private const int GetNodesTimeout = 500;
private const int UpdateHandshakeTimeout = 400; |
<<<<<<<
using AElf.Cryptography;
=======
>>>>>>>
using AElf.Cryptography;
<<<<<<<
=======
using Moq;
>>>>>>>
using Moq; |
<<<<<<<
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(TokenContract.InitializeTokenContract), new IntializeTokenContractInput
=======
var tokenContractCallList = new SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.InitializeTokenContract), new IntializeTokenContractInput
>>>>>>>
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.InitializeTokenContract), new IntializeTokenContractInput |
<<<<<<<
using AElf.Configuration.Config.Chain;
using AElf.Kernel.Extensions;
=======
>>>>>>>
using AElf.Kernel.Extensions; |
<<<<<<<
p1.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("bHash1"))))
.Returns<Hash>(h => Task.FromResult(new BlockWithTransactions()));
=======
p1.Setup(p => p.RequestBlockAsync(It.Is<Hash>(h => h == Hash.FromString("bHash1"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions));
>>>>>>>
p1.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("bHash1"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions));
<<<<<<<
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { new BlockWithTransactions() }));
p2.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("block"))))
.Returns<Hash>(h => Task.FromResult(new BlockWithTransactions()));
=======
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { blockWithTransactions }));
p2.Setup(p => p.RequestBlockAsync(It.Is<Hash>(h => h == Hash.FromString("block"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions));
>>>>>>>
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { blockWithTransactions }));
p2.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("block"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions));
<<<<<<<
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { new BlockWithTransactions(), new BlockWithTransactions() }));
p3.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("bHash2"))))
.Returns<Hash>(h => Task.FromResult(new BlockWithTransactions()));
=======
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { blockWithTransactions, blockWithTransactions }));
p3.Setup(p => p.RequestBlockAsync(It.Is<Hash>(h => h == Hash.FromString("bHash2"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions));
>>>>>>>
.Returns<Hash, int>((h, cnt) => Task.FromResult(new List<BlockWithTransactions> { blockWithTransactions, blockWithTransactions }));
p3.Setup(p => p.GetBlockByHashAsync(It.Is<Hash>(h => h == Hash.FromString("bHash2"))))
.Returns<Hash>(h => Task.FromResult(blockWithTransactions)); |
<<<<<<<
Logger.LogTrace($"Before filter:");
foreach (var tx in sysTxs)
{
Logger.LogTrace($"{tx.GetHash()} - {tx.MethodName}");
}
=======
>>>>>>>
<<<<<<<
Logger.LogTrace($"After filter:");
foreach (var tx in sysTxs)
{
Logger.LogTrace($"{tx.GetHash()} - {tx.MethodName}");
}
Logger.LogTrace($"Start executing {sysTxs.Count} system transactions.");
traces = await ExecuteTransactions(sysTxs, true, TransactionType.DposTransaction);
Logger.LogTrace($"Finish executing {sysTxs.Count} system transactions.");
=======
_logger?.Trace($"Start executing {sysTxs.Count} system transactions.");
traces = await ExecuteTransactions(sysTxs, currentBlockTime,true, TransactionType.DposTransaction);
_logger?.Trace($"Finish executing {sysTxs.Count} system transactions.");
>>>>>>>
Logger.LogTrace($"Start executing {sysTxs.Count} system transactions.");
traces = await ExecuteTransactions(sysTxs, currentBlockTime,true, TransactionType.DposTransaction);
Logger.LogTrace($"Finish executing {sysTxs.Count} system transactions.");
<<<<<<<
var block = await GenerateBlockAsync(results, sideChainTransactionsRoot, indexedSideChainBlockInfo);
Logger.LogInformation($"Generated block {block.BlockHashToHex} at height {block.Header.Index} with {block.Body.TransactionsCount} txs.");
=======
var block = await GenerateBlock(results, sideChainTransactionsRoot, indexedSideChainBlockInfo,
currentBlockTime);
_logger?.Info($"Generated block {block.BlockHashToHex} at height {block.Header.Index} with {block.Body.TransactionsCount} txs.");
>>>>>>>
var block = await GenerateBlock(results, sideChainTransactionsRoot, indexedSideChainBlockInfo,
currentBlockTime);
Logger.LogInformation($"Generated block {block.BlockHashToHex} at height {block.Header.Index} with {block.Body.TransactionsCount} txs."); |
<<<<<<<
=======
Cts = new CancellationTokenSource();
>>>>>>>
<<<<<<<
readyTxs = tuple.Item2;
var distanceToTimeSlot = (double)ConsensusConfig.Instance.DPoSMiningInterval;
if (block.Header.Index > 2)
{
var timeSlot = await _dpoSInfoProvider.GetDistanceToTimeSlot();
if (timeSlot > 0)
{
distanceToTimeSlot = timeSlot;
}
}
cts.CancelAfter(TimeSpan.FromMilliseconds(distanceToTimeSlot * 3 / 4));
var trs = await _txHub.GetReceiptsForAsync(readyTxs, cts);
if (cts.IsCancellationRequested)
{
return BlockExecutionResult.ExecutionCancelled;
}
=======
var trs = await _txHub.GetReceiptsForAsync(readyTxs);
>>>>>>>
var distanceToTimeSlot = (double)ConsensusConfig.Instance.DPoSMiningInterval;
if (block.Header.Index > 2)
{
var timeSlot = await _dpoSInfoProvider.GetDistanceToTimeSlot();
if (timeSlot > 0)
{
distanceToTimeSlot = timeSlot;
}
}
cts.CancelAfter(TimeSpan.FromMilliseconds(distanceToTimeSlot * 3 / 4));
var trs = await _txHub.GetReceiptsForAsync(readyTxs, cts);
if (cts.IsCancellationRequested)
{
return BlockExecutionResult.ExecutionCancelled;
} |
<<<<<<<
context.Services.AddTransient<ISystemTransactionRecognizer, DonateTransactionRecognizer>();
context.Services.AddTransient<ITransactionValidationProvider, TxHubEntryPermissionValidationProvider>();
context.Services.AddTransient<ITransactionValidationProvider, TransactionMethodNameValidationProvider>();
context.Services.AddSingleton<IChargeFeeStrategy, TokenContractChargeFeeStrategy>();
=======
>>>>>>>
context.Services.AddTransient<ITransactionValidationProvider, TxHubEntryPermissionValidationProvider>();
context.Services.AddTransient<ITransactionValidationProvider, TransactionMethodNameValidationProvider>();
context.Services.AddSingleton<IChargeFeeStrategy, TokenContractChargeFeeStrategy>(); |
<<<<<<<
using AElf.Node.EventMessages;
using Easy.MessageHub;
=======
using AElf.Common;
using Easy.MessageHub;
>>>>>>>
using AElf.Node.EventMessages;
using Easy.MessageHub;
<<<<<<<
private readonly IBlockExecutionService _blockExecutionService;
=======
private readonly TxHub _txHub;
>>>>>>>
private readonly IBlockExecutionService _blockExecutionService;
private readonly TxHub _txHub;
<<<<<<<
NodeConfig.Instance.ECKeyPair = conf.KeyPair;
=======
_txHub.CurrentHeightGetter = ()=> _blockChain.GetCurrentBlockHeightAsync().Result;
MessageHub.Instance.Subscribe<BlockHeader>((bh)=>_txHub.OnNewBlockHeader(bh));
>>>>>>>
NodeConfig.Instance.ECKeyPair = conf.KeyPair;
_txHub.CurrentHeightGetter = ()=> _blockChain.GetCurrentBlockHeightAsync().Result;
MessageHub.Instance.Subscribe<BlockHeader>((bh)=>_txHub.OnNewBlockHeader(bh));
<<<<<<<
//Task.Run(() => _synchronizer.Start(this, !NodeConfig.Instance.ConsensusInfoGenerater));
_blockExecutor.Start();
_blockExecutionService.Start();
=======
Task.Run(() => _synchronizer.Start(this, !NodeConfig.Instance.ConsensusInfoGenerater));
_blockExecutor.Init();
>>>>>>>
Task.Run(() => _synchronizer.Start(this, !NodeConfig.Instance.ConsensusInfoGenerator));
_blockExecutor.Init();
_blockExecutionService.Start();
<<<<<<<
if (!NodeConfig.Instance.IsMiner)
return;
SetupConsensus();
=======
if (NodeConfig.Instance.IsMiner)
{
_miner.Init(_nodeKeyPair);
_logger?.Log(LogLevel.Debug, "Coinbase = \"{0}\"", _miner.Coinbase.DumpHex());
SetupConsensus();
_consensus?.Start();
}
_blockExecutor.FinishInitialSync();
>>>>>>>
if (NodeConfig.Instance.IsMiner)
{
SetupConsensus();
_consensus?.Start();
}
// if (NodeConfig.Instance.IsMiner)
// {
// _miner.Init(_nodeKeyPair);
// _logger?.Log(LogLevel.Debug, "Coinbase = \"{0}\"", _miner.Coinbase.DumpHex());
// SetupConsensus();
// _consensus?.Start();
// }
// _blockExecutor.FinishInitialSync(); |
<<<<<<<
private bool IsMining { get; set; }
private ECKeyPair NodeKeyPair => Node.NodeKeyPair;
=======
public IDisposable ConsensusDisposable { get; set; }
private readonly IWorldStateDictator _worldStateDictator;
>>>>>>>
private bool IsMining { get; set; }
<<<<<<<
private AElfDPoSObserver AElfDPoSObserver => new AElfDPoSObserver(_logger,
=======
private ECKeyPair _nodeKeyPair;
private Hash _contractAccountAddressHash;
public ulong ConsensusMemory { get; set; }
private bool IsMining { get; set; }
private int _flag;
public AElfDPoSObserver AElfDPoSObserver => new AElfDPoSObserver(_logger,
>>>>>>>
private ECKeyPair _nodeKeyPair;
private Hash _contractAccountAddressHash;
private int _flag;
public AElfDPoSObserver AElfDPoSObserver => new AElfDPoSObserver(_logger,
<<<<<<<
public DPoS(ILogger logger, MainChainNode node, IStateDictator stateDictator, IAccountContextService accountContextService, ITxPoolService txPoolService, IP2P p2p
)
=======
public DPoS(ILogger logger,
IWorldStateDictator worldStateDictator,
IAccountContextService accountContextService,
ITxPoolService txPoolService,
IP2P p2p,
IMiner miner,
IBlockChain blockchain,
IBlockSynchronizer syncer)
>>>>>>>
public DPoS(ILogger logger,
IStateDictator stateDictator,
IAccountContextService accountContextService,
ITxPoolService txPoolService,
IP2P p2p,
IMiner miner,
IBlockChain blockchain,
IBlockSynchronizer syncer
)
<<<<<<<
Node = node;
_stateDictator = stateDictator;
=======
}
public void Initialize(Hash contractAccountHash, ECKeyPair nodeKeyPair)
{
_dposHelpers = new AElfDPoSHelper(_worldStateDictator, nodeKeyPair, ByteArrayHelpers.FromHexString(NodeConfig.Instance.ChainId), BlockProducers, contractAccountHash, _logger);
_nodeKeyPair = nodeKeyPair;
_contractAccountAddressHash = contractAccountHash;
>>>>>>>
}
public void Initialize(Hash contractAccountHash, ECKeyPair nodeKeyPair)
{
_dposHelpers = new AElfDPoSHelper(_stateDictator, ByteArrayHelpers.FromHexString(NodeConfig.Instance.ChainId), Miners, contractAccountHash, _logger);
_nodeKeyPair = nodeKeyPair;
_contractAccountAddressHash = contractAccountHash;
<<<<<<<
if (!Miners.Nodes.Contains(NodeKeyPair.GetAddress().ToHex().RemoveHexPrefix()))
=======
if (!BlockProducers.Nodes.Contains(_nodeKeyPair.GetAddress().ToHex().RemoveHexPrefix()))
>>>>>>>
if (!Miners.Nodes.Contains(_nodeKeyPair.GetAddress().ToHex().RemoveHexPrefix()))
<<<<<<<
DPoSHelper.SyncMiningInterval();
_logger?.Trace($"Sync AElf DPoS mining interval to: {Globals.AElfDPoSMiningInterval} ms.");
=======
_dposHelpers.SyncMiningInterval();
_logger?.Trace($"Set AElf DPoS mining interval: {Globals.AElfDPoSMiningInterval} ms.");
>>>>>>>
_dposHelpers.SyncMiningInterval();
_logger?.Trace($"Set AElf DPoS mining interval to: {Globals.AElfDPoSMiningInterval} ms.");
<<<<<<<
Miners.ToByteArray(),
DPoSHelper.GenerateInfoForFirstTwoRounds().ToByteArray(),
new SInt32Value {Value = Globals.AElfDPoSMiningInterval}.ToByteArray()
=======
BlockProducers.ToByteArray(),
_dposHelpers.GenerateInfoForFirstTwoRounds().ToByteArray(),
new Int32Value {Value = Globals.AElfDPoSMiningInterval}.ToByteArray()
>>>>>>>
Miners.ToByteArray(),
_dposHelpers.GenerateInfoForFirstTwoRounds().ToByteArray(),
new SInt32Value {Value = Globals.AElfDPoSMiningInterval}.ToByteArray()
<<<<<<<
var block = await Node.Mine(true);
=======
var block = await Mine();
>>>>>>>
var block = await Mine(true);
<<<<<<<
bool isDPoS = addr.Equals(NodeKeyPair.GetAddress()) ||
DPoSHelper.Miners.Nodes.Contains(addr.ToHex().RemoveHexPrefix());
=======
bool isDPoS = addr.Equals(_nodeKeyPair.GetAddress()) ||
_dposHelpers.BlockProducer.Nodes.Contains(addr.ToHex().RemoveHexPrefix());
>>>>>>>
bool isDPoS = addr.Equals(_nodeKeyPair.GetAddress()) ||
_dposHelpers.Miners.Nodes.Contains(addr.ToHex().RemoveHexPrefix());
<<<<<<<
_logger?.Log(LogLevel.Debug, "MiningWithUpdatingAElf..");
var extraBlockResult = DPoSHelper.ExecuteTxsForExtraBlock();
_logger?.Log(LogLevel.Debug, "End MiningWithUpdatingAElf..");
=======
var extraBlockResult = await _dposHelpers.ExecuteTxsForExtraBlock();
>>>>>>>
var extraBlockResult = _dposHelpers.ExecuteTxsForExtraBlock();
<<<<<<<
_logger?.Trace(DPoSHelper.GetDPoSInfo(header.Index));
=======
_logger?.Trace(await _dposHelpers.GetDPoSInfo(header.Index));
>>>>>>>
_logger?.Trace(_dposHelpers.GetDPoSInfo(header.Index)); |
<<<<<<<
peer = await _peerDialer.DialPeerAsync(ipAddress);
Logger.LogWarning($"Dialed peer: in {peer.InboundSessionId.ToHex()}, out {peer.OutboundSessionId.ToHex()}.");
=======
peer = await _peerDialer.DialPeerAsync(endpoint);
>>>>>>>
peer = await _peerDialer.DialPeerAsync(endpoint);
Logger.LogWarning($"Dialed peer: in {peer.InboundSessionId.ToHex()}, out {peer.OutboundSessionId.ToHex()}."); |
<<<<<<<
using System.Threading;
using AElf.Sdk.CSharp;
=======
using AElf.CSharp.Core;
>>>>>>>
using System.Threading;
using AElf.Sdk.CSharp;
using AElf.CSharp.Core; |
<<<<<<<
var existing = State.TokenInfos[input.Symbol];
Assert(existing == null && !string.IsNullOrEmpty(input.Symbol),
$"Token already exists. Symbol: {input.Symbol}");
=======
>>>>>>>
<<<<<<<
IsBurnable = input.IsBurnable,
IsTransferDisabled = input.IsTransferDisabled
=======
IsBurnable = input.IsBurnable,
IssueChainId = Context.ChainId
>>>>>>>
IsBurnable = input.IsBurnable,
IsTransferDisabled = input.IsTransferDisabled,
IssueChainId = Context.ChainId
<<<<<<<
/// Transfer token form a chain to another chain
/// burn the tokens at the current chain
=======
/// Transfer token form this chain to another one.
>>>>>>>
/// Transfer token form a chain to another chain
/// burn the tokens at the current chain
<<<<<<<
if (State.CrossChainContract.Value == null)
State.CrossChainContract.Value =
Context.GetContractAddressByName(SmartContractConstants.CrossChainContractSystemName);
var verificationInput = new VerifyTransactionInput
{
TransactionId = transferTransactionId,
ParentChainHeight = input.ParentChainHeight,
VerifiedChainId = input.FromChainId
};
verificationInput.Path.AddRange(input.MerklePath);
if (State.CrossChainContract.Value == null)
State.CrossChainContract.Value =
Context.GetContractAddressByName(SmartContractConstants.CrossChainContractSystemName);
var verificationResult =
State.CrossChainContract.VerifyTransaction.Call(verificationInput);
Assert(verificationResult.Value, "Verification failed.");
// Create token if it doesnt exist.
var existing = State.TokenInfos[symbol];
if (existing == null)
RegisterTokenInfo(crossChainTransferInput.TokenInfo);
=======
var registeredTokenContractAddress = State.CrossChainTransferWhiteList[input.FromChainId];
AssertCrossChainTransaction(transferTransaction, registeredTokenContractAddress,
nameof(CrossChainTransfer));
Context.LogDebug(() =>
$"symbol == {symbol}, amount == {amount}, receivingAddress == {receivingAddress}, targetChainId == {targetChainId}");
CrossChainVerify(transferTransactionId, input.ParentChainHeight, input.FromChainId, input.MerklePath);
>>>>>>>
var registeredTokenContractAddress = State.CrossChainTransferWhiteList[input.FromChainId];
AssertCrossChainTransaction(transferTransaction, registeredTokenContractAddress,
nameof(CrossChainTransfer));
Context.LogDebug(() =>
$"symbol == {symbol}, amount == {amount}, receivingAddress == {receivingAddress}, targetChainId == {targetChainId}");
CrossChainVerify(transferTransactionId, input.ParentChainHeight, input.FromChainId, input.MerklePath); |
<<<<<<<
using Org.BouncyCastle.Asn1.X9;
using AElf.Miner.Rpc.Exceptions;
=======
using AElf.Miner.Rpc.Exceptions;
>>>>>>>
using Org.BouncyCastle.Asn1.X9;
using AElf.Miner.Rpc.Exceptions;
<<<<<<<
Transaction genTx= await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo);
var bn = await _blockChain.GetCurrentBlockHeightAsync();
// remove invalid CrossChainBlockInfoTransaction, only that from local can be executed)
/*readyTxs.RemoveAll(t =>
t.Type == TransactionType.CrossChainBlockInfoTransaction &&
!t.GetHash().Equals(genTx.GetHash()));*/
var dposTxs = readyTxs.Where(tx => tx.Type == TransactionType.DposTransaction);
_logger?.Trace($"Will package {dposTxs.Count()} DPoS txs.");
foreach (var transaction in dposTxs)
{
_logger?.Trace($"{transaction.GetHash().DumpHex()} - {transaction.MethodName} from {transaction.From.DumpHex()}");
}
var disambiguationHash = HashHelpers.GetDisambiguationHash(await GetNewBlockIndexAsync(), _producerAddress);
=======
var genTx = await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo);
>>>>>>>
Transaction genTx= await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo);
var bn = await _blockChain.GetCurrentBlockHeightAsync();
// remove invalid CrossChainBlockInfoTransaction, only that from local can be executed)
/*readyTxs.RemoveAll(t =>
t.Type == TransactionType.CrossChainBlockInfoTransaction &&
!t.GetHash().Equals(genTx.GetHash()));*/
var dposTxs = readyTxs.Where(tx => tx.Type == TransactionType.DposTransaction);
_logger?.Trace($"Will package {dposTxs.Count()} DPoS txs.");
foreach (var transaction in dposTxs)
{
_logger?.Trace($"{transaction.GetHash().DumpHex()} - {transaction.MethodName} from {transaction.From.DumpHex()}");
}
var disambiguationHash = HashHelpers.GetDisambiguationHash(await GetNewBlockIndexAsync(), _producerAddress);
<<<<<<<
//<<<<<<< HEAD
private async Task<ulong> GetNewBlockIndexAsync()
{
var blockChain = _chainService.GetBlockChain(Config.ChainId);
var index = await blockChain.GetCurrentBlockHeightAsync() + 1;
return index;
}
private async Task UpdateParentChainBlockInfo(ParentChainBlockInfo parentChainBlockInfo)
{
await _clientManager.UpdateParentChainBlockInfo(parentChainBlockInfo);
}
// private void BroadcastBlock(IBlock block)
// {
// MessageHub.Instance.Publish(new BlockMinedMessage(block));
// }
//=======
//
//>>>>>>> dev
=======
>>>>>>>
private async Task<ulong> GetNewBlockIndexAsync()
{
var blockChain = _chainService.GetBlockChain(Config.ChainId);
var index = await blockChain.GetCurrentBlockHeightAsync() + 1;
return index;
}
private async Task UpdateParentChainBlockInfo(ParentChainBlockInfo parentChainBlockInfo)
{
await _clientManager.UpdateParentChainBlockInfo(parentChainBlockInfo);
}
<<<<<<<
StateHash=trace.GetSummarizedStateHash(),
Index = index++,
Transaction = trace.Transaction
=======
Index = index++,
Transaction = trace.Transaction
>>>>>>>
StateHash=trace.GetSummarizedStateHash(),
Index = index++,
Transaction = trace.Transaction
<<<<<<<
_keyPair = NodeConfig.Instance.ECKeyPair;
_producerAddress = Address.FromRawBytes(_keyPair.GetEncodedPublicKey());
=======
_keyPair = NodeConfig.Instance.ECKeyPair;
>>>>>>>
_keyPair = NodeConfig.Instance.ECKeyPair;
_producerAddress = Address.FromRawBytes(_keyPair.GetEncodedPublicKey()); |
<<<<<<<
context.Services.SetConfiguration(Configuration);
Configure<ChainOptions>(option =>
{
option.ChainId = ChainHelpers.ConvertBase58ToChainId(Configuration["ChainId"]);
option.IsMainChain = Convert.ToBoolean(Configuration["IsMainChain"]);
});
=======
>>>>>>>
<<<<<<<
if (chainOptions.IsMainChain)
dto.InitializationSmartContracts.AddGenesisSmartContract<ConsensusContract>(
ConsensusSmartContractAddressNameProvider.Name);
else
{
dto.InitializationSmartContracts.AddGenesisSmartContract(typeof(SideChain.ConsensusContract));
ConsensusSmartContractAddressNameProvider.Name = Hash.FromString(typeof(SideChain.ConsensusContract).FullName);
}
dto.InitializationSmartContracts.AddGenesisSmartContract<TokenContract>(TokenSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<DividendsContract>(DividendsSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<ResourceContract>(ResourceSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<FeeReceiverContract>(ResourceFeeReceiverSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<CrossChainContract>(CrossChainSmartContractAddressNameProvider.Name);
=======
dto.InitializationSmartContracts.AddGenesisSmartContract<ConsensusContract>(
ConsensusSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<TokenContract>(
TokenSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<DividendsContract>(
DividendsSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<ResourceContract>(
ResourceSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<FeeReceiverContract>(
ResourceFeeReceiverSmartContractAddressNameProvider.Name);
>>>>>>>
if (chainOptions.IsMainChain)
dto.InitializationSmartContracts.AddGenesisSmartContract<ConsensusContract>(
ConsensusSmartContractAddressNameProvider.Name);
else
{
dto.InitializationSmartContracts.AddGenesisSmartContract(typeof(SideChain.ConsensusContract));
ConsensusSmartContractAddressNameProvider.Name = Hash.FromString(typeof(SideChain.ConsensusContract).FullName);
}
dto.InitializationSmartContracts.AddGenesisSmartContract<TokenContract>(TokenSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<DividendsContract>(DividendsSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<ResourceContract>(ResourceSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<FeeReceiverContract>(ResourceFeeReceiverSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract<CrossChainContract>(CrossChainSmartContractAddressNameProvider.Name); |
<<<<<<<
=======
// TODO: We can merge some Ids.
>>>>>>>
<<<<<<<
=======
>>>>>>>
<<<<<<<
=======
public SingletonState<Hash> RewardHash { get; set; }
public SingletonState<Hash> BasicRewardHash { get; set; }
public SingletonState<Hash> VotesWeightRewardHash { get; set; }
public SingletonState<Hash> ReElectionRewardHash { get; set; }
>>>>>>>
<<<<<<<
=======
public SingletonState<long> CachedWelfareWeight { get; set; }
>>>>>>> |
<<<<<<<
using System;
=======
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using AElf.Common;
using AElf.Database;
using AElf.Kernel.Blockchain.Application;
using AElf.Kernel.Infrastructure;
>>>>>>>
using System;
<<<<<<<
=======
using AElf.TestBase;
using Google.Protobuf.WellKnownTypes;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using Volo.Abp;
using Volo.Abp.EventBus;
>>>>>>> |
<<<<<<<
public SmartContractService(ISmartContractManager smartContractManager, ISmartContractRunnerFactory smartContractRunnerFactory, IStateManager stateManager,
=======
public SmartContractService(ISmartContractManager smartContractManager, ISmartContractRunnerContainer smartContractRunnerContainer, IStateStore stateStore,
>>>>>>>
public SmartContractService(ISmartContractManager smartContractManager, ISmartContractRunnerContainer smartContractRunnerContainer, IStateManager stateManager,
<<<<<<<
_smartContractRunnerFactory = smartContractRunnerFactory;
_stateManager = stateManager;
=======
_smartContractRunnerContainer = smartContractRunnerContainer;
_stateStore = stateStore;
>>>>>>>
_smartContractRunnerContainer = smartContractRunnerContainer;
_stateManager = stateManager; |
<<<<<<<
_transactionManager = new TransactionManager(_dataStore);
_transactionReceiptManager = new TransactionReceiptManager(_database);
_smartContractManager = new SmartContractManager(_dataStore);
_transactionResultManager = new TransactionResultManager(_dataStore);
_transactionTraceManager = new TransactionTraceManager(_dataStore);
_functionMetadataService = new FunctionMetadataService(_dataStore);
_chainManager = new ChainManager(_dataStore);
_chainService = new ChainService(_chainManager, new BlockManager(_dataStore),
_transactionManager, _transactionTraceManager, _dataStore, StateStore);
=======
_chainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, _stateManager);
>>>>>>>
_chainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, _stateManager);
<<<<<<<
StateStore, _functionMetadataService));
=======
_stateManager, _functionMetadataService), _logger);
>>>>>>>
_stateManager, _functionMetadataService));
<<<<<<<
_transactionResultManager, clientManager, _binaryMerkleTreeManager, null,
MockBlockValidationService().Object, _chainContextService, _stateStore);
=======
_transactionResultManager, _logger, clientManager, _binaryMerkleTreeManager, null,
MockBlockValidationService().Object, _chainContextService, _chainManager, _stateManager);
>>>>>>>
_transactionResultManager, clientManager, _binaryMerkleTreeManager, null,
MockBlockValidationService().Object, _chainContextService, _chainManager, _stateManager);
<<<<<<<
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfoReader, _signatureVerifier, _refBlockValidator), StateStore);
=======
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfoReader, _signatureVerifier, _refBlockValidator, null), _chainManager, _stateManager);
>>>>>>>
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfoReader, _signatureVerifier, _refBlockValidator), _chainManager, _stateManager); |
<<<<<<<
=======
using System.Threading;
using AElf.ChainController.EventMessages;
>>>>>>>
using System.Threading;
using AElf.ChainController.EventMessages;
<<<<<<<
_logger?.Trace($"[NodeState] Entering State {_fsm.CurrentState.ToString()}");
MessageHub.Instance.Publish(new EnteringState(_fsm.CurrentState));
=======
_logger?.Trace($"[NodeState] Entering State {((NodeState) _fsm.CurrentState).ToString()}");
MessageHub.Instance.Publish(new EnteringState((NodeState) _fsm.CurrentState));
if (_inAState == 1)
{
_logger?.Trace("Unexpected entering of current state.");
}
Interlocked.Add(ref _inAState, 1);
>>>>>>>
_logger?.Trace($"[NodeState] Entering State {((NodeState) _fsm.CurrentState).ToString()}");
MessageHub.Instance.Publish(new EnteringState((NodeState) _fsm.CurrentState));
if (_inAState == 1)
{
_logger?.Trace("Unexpected entering of current state.");
}
Interlocked.Add(ref _inAState, 1);
<<<<<<<
_logger?.Trace($"[NodeState] Leaving State {_fsm.CurrentState.ToString()}");
MessageHub.Instance.Publish(new LeavingState(_fsm.CurrentState));
=======
_logger?.Trace($"[NodeState] Leaving State {((NodeState) _fsm.CurrentState).ToString()}");
MessageHub.Instance.Publish(new LeavingState((NodeState) _fsm.CurrentState));
if (_inAState == 0)
{
_logger?.Trace("Unexpected leaving of current state.");
}
Interlocked.Add(ref _inAState, 0);
>>>>>>>
_logger?.Trace($"[NodeState] Leaving State {((NodeState) _fsm.CurrentState).ToString()}");
MessageHub.Instance.Publish(new LeavingState((NodeState) _fsm.CurrentState));
if (_inAState == 0)
{
_logger?.Trace("Unexpected leaving of current state.");
}
Interlocked.Add(ref _inAState, 0); |
<<<<<<<
=======
private Hash _blockHash;
partial void OnConstruction()
{
Bloom = ByteString.CopyFrom(new Bloom().Data);
}
>>>>>>>
private Hash _blockHash; |
<<<<<<<
using AElf.Configuration.Config.Chain;
using AElf.Crosschain.Client;
using AElf.Crosschain.Exceptions;
=======
>>>>>>>
using AElf.Configuration.Config.Chain;
using AElf.Crosschain.Client;
using AElf.Crosschain.Exceptions;
<<<<<<<
using AElf.Kernel.Types.Common;
using AElf.Kernel.Types.Transaction;
=======
using AElf.Miner.Rpc.Client;
using AElf.Miner.Rpc.Exceptions;
>>>>>>>
using AElf.Miner.Rpc.Client;
using AElf.Miner.Rpc.Exceptions;
using AElf.Kernel.Types.Common;
using AElf.Kernel.Types.Transaction; |
<<<<<<<
CancellationToken cancellationToken, Hash disambiguationHash = null,
TransactionType transactionType = TransactionType.ContractTransaction,
bool skipFee = false)
=======
CancellationToken cancellationToken, DateTime currentBlockTime, Hash disambiguationHash = null,
TransactionType transactionType = TransactionType.ContractTransaction)
>>>>>>>
DateTime currentBlockTime, CancellationToken cancellationToken, Hash disambiguationHash = null,
TransactionType transactionType = TransactionType.ContractTransaction,
bool skipFee = false)
<<<<<<<
var trace = await ExecuteOneAsync(0, transaction, chainId, chainContext, stateCache, cancellationToken,
skipFee);
if (!trace.IsSuccessful())
=======
var trace = await ExecuteOneAsync(0, transaction, chainId, chainContext, currentBlockTime, stateCache,
cancellationToken);
//Console.WriteLine($"{transaction.GetHash().ToHex()} : {trace.ExecutionStatus.ToString()}");
if (trace.IsSuccessful())
{
if (trace.ExecutionStatus == ExecutionStatus.ExecutedButNotCommitted)
{
await trace.CommitChangesAsync(_stateManager);
}
}
else
>>>>>>>
var trace = await ExecuteOneAsync(0, transaction, chainId, chainContext, stateCache, currentBlockTime, cancellationToken,
skipFee);
if (!trace.IsSuccessful())
<<<<<<<
IChainContext chainContext, Dictionary<StatePath, StateCache> stateCache,
CancellationToken cancellationToken, bool skipFee = false)
=======
IChainContext chainContext, DateTime currentBlockTime, Dictionary<StatePath, StateCache> stateCache,
CancellationToken cancellationToken)
>>>>>>>
IChainContext chainContext, Dictionary<StatePath, StateCache> stateCache, DateTime currentBlockTime,
CancellationToken cancellationToken, bool skipFee = false)
<<<<<<<
var inlineTrace = await ExecuteOneAsync(depth + 1, inlineTx, chainId, chainContext, stateCache,
cancellationToken, skipFee);
=======
var inlineTrace = await ExecuteOneAsync(depth + 1, inlineTx, chainId, chainContext,
currentBlockTime, stateCache, cancellationToken);
>>>>>>>
var inlineTrace = await ExecuteOneAsync(depth + 1, inlineTx, chainId, chainContext, stateCache,
currentBlockTime, cancellationToken, skipFee); |
<<<<<<<
await _worldStateDictator.SetWorldStateAsync(lastBlockHash);
_logger?.Log(LogLevel.Debug, "End Set WS..");
var ws = await _worldStateDictator.GetWorldStateAsync(lastBlockHash);
_logger?.Log(LogLevel.Debug, "End Get Ws");
=======
await _worldStateDictator.SetWorldStateAsync(currentBlockHash);
var ws = await _worldStateDictator.GetWorldStateAsync(currentBlockHash);
>>>>>>>
await _worldStateDictator.SetWorldStateAsync(currentBlockHash);
_logger?.Log(LogLevel.Debug, "End Set WS..");
var ws = await _worldStateDictator.GetWorldStateAsync(currentBlockHash);
_logger?.Log(LogLevel.Debug, "End Get Ws"); |
<<<<<<<
using Microsoft.IdentityModel.Protocols;
using Volo.Abp;
=======
>>>>>>>
<<<<<<<
var cultureInfo = new CultureInfo(_configuration["DefaultCulture"]);
//var cultureInfo = new CultureInfo("en-US");
CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
app.UseCors(builder => builder
.WithOrigins(_configuration["CorsOrigins"]
.Split(",", StringSplitOptions.RemoveEmptyEntries)
.Select(o => o.RemovePostFix("/"))
.ToArray())
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials()
);
=======
app.UseRouting();
app.UseCors(DefaultCorsPolicyName);
>>>>>>>
var cultureInfo = new CultureInfo(_configuration["DefaultCulture"]);
//var cultureInfo = new CultureInfo("en-US");
CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
app.UseRouting();
app.UseCors(DefaultCorsPolicyName); |
<<<<<<<
Hash TransactionId { get; }
=======
int ChainId { get; }
// TODO: Remove Transaction
Transaction Transaction { get; }
Hash TransactionId { get; }
>>>>>>>
Hash TransactionId { get; }
int ChainId { get; }
// TODO: Remove Transaction
Transaction Transaction { get; }
Hash TransactionId { get; }
<<<<<<<
byte[] RecoverPublicKey();
=======
// TODO: Remove genesis
Address Genesis { get; }
ulong CurrentHeight { get; }
DateTime CurrentBlockTime { get; }
Hash PreviousBlockHash { get; }
// TODO: Remove RecoverPublicKey(byte[] signature, byte[] hash)
byte[] RecoverPublicKey(byte[] signature, byte[] hash);
byte[] RecoverPublicKey();
// TODO: Remove GetBlockByHeight
>>>>>>>
byte[] RecoverPublicKey();
// TODO: Remove genesis
Address Genesis { get; }
ulong CurrentHeight { get; }
DateTime CurrentBlockTime { get; }
Hash PreviousBlockHash { get; }
// TODO: Remove RecoverPublicKey(byte[] signature, byte[] hash)
byte[] RecoverPublicKey(byte[] signature, byte[] hash);
byte[] RecoverPublicKey();
// TODO: Remove GetBlockByHeight
<<<<<<<
=======
bool VerifySignature(Transaction tx);
/// <summary>
/// Generate txn not executed before next block.
/// </summary>
/// <param name="deferredTxn"></param>
void SendDeferredTransaction(Transaction deferredTxn);
Task DeployContractAsync(Address address, SmartContractRegistration registration);
Task UpdateContractAsync(Address address, SmartContractRegistration registration);
>>>>>>>
bool VerifySignature(Transaction tx);
/// <summary>
/// Generate txn not executed before next block.
/// </summary>
/// <param name="deferredTxn"></param>
void SendDeferredTransaction(Transaction deferredTxn);
Task DeployContractAsync(Address address, SmartContractRegistration registration);
Task UpdateContractAsync(Address address, SmartContractRegistration registration); |
<<<<<<<
typeof(GrpcCrossChainAElfModule),
=======
//TODO: should move to OSAElfModule
>>>>>>>
typeof(GrpcCrossChainAElfModule),
//TODO: should move to OSAElfModule |
<<<<<<<
builder.RegisterType<BlockValidationService>().As<IBlockValidationService>().SingleInstance();
builder.RegisterType<ChainContextService>().As<IChainContextService>().SingleInstance();
builder.RegisterType<ChainService>().As<IChainService>().SingleInstance();
builder.RegisterType<BlockSet>().As<IBlockSet>().SingleInstance();
builder.RegisterType<ChainManagerBasic>().As<IChainManagerBasic>().SingleInstance();
builder.RegisterType<BlockManagerBasic>().As<IBlockManagerBasic>().SingleInstance();
builder.RegisterType<TransactionManager>().As<ITransactionManager>().SingleInstance();
=======
builder.RegisterType<StateStore>().As<IStateStore>();
>>>>>>>
builder.RegisterType<BlockValidationService>().As<IBlockValidationService>().SingleInstance();
builder.RegisterType<ChainContextService>().As<IChainContextService>().SingleInstance();
builder.RegisterType<ChainService>().As<IChainService>().SingleInstance();
builder.RegisterType<BlockSet>().As<IBlockSet>().SingleInstance();
builder.RegisterType<ChainManagerBasic>().As<IChainManagerBasic>().SingleInstance();
builder.RegisterType<BlockManagerBasic>().As<IBlockManagerBasic>().SingleInstance();
builder.RegisterType<TransactionManager>().As<ITransactionManager>().SingleInstance();
builder.RegisterType<StateStore>().As<IStateStore>(); |
<<<<<<<
nodeConfig.IsChainCreator = confParser.NewChain;
var runner = new SmartContractRunner("../AElf.SDK.CSharp/bin/Debug/netstandard2.0/");
=======
var runner = new SmartContractRunner(confParser.RunnerConfig);
>>>>>>>
nodeConfig.IsChainCreator = confParser.NewChain;
var runner = new SmartContractRunner(confParser.RunnerConfig); |
<<<<<<<
private const int FinalizeConnectTimeout = 500;
=======
private const int GetNodesTimeout = 500;
>>>>>>>
private const int GetNodesTimeout = 500;
private const int FinalizeConnectTimeout = 500;
<<<<<<<
public async Task<FinalizeConnectReply> FinalizeConnectAsync(Handshake handshake)
{
GrpcRequest request = new GrpcRequest { ErrorMessage = $"Error while finalizing request to {this}." };
Metadata data = new Metadata { {GrpcConstants.TimeoutMetadataKey, FinalizeConnectTimeout.ToString()} };
var finalizeConnectReply = await RequestAsync(_client, c => c.FinalizeConnectAsync(handshake, data), request);
IsConnected = finalizeConnectReply.Success;
return finalizeConnectReply;
}
public async Task<BlockWithTransactions> GetBlockByHashAsync(Hash hash)
=======
public Task<NodeList> GetNodesAsync(int count = NetworkConstants.DefaultDiscoveryMaxNodesToRequest)
{
GrpcRequest request = new GrpcRequest
{
ErrorMessage = $"Request nodes failed."
};
Metadata data = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, GetNodesTimeout.ToString()}
};
return RequestAsync(_client, c => c.GetNodesAsync(new NodesRequest { MaxCount = count }, data), request);
}
public async Task<BlockWithTransactions> RequestBlockAsync(Hash hash)
>>>>>>>
public Task<NodeList> GetNodesAsync(int count = NetworkConstants.DefaultDiscoveryMaxNodesToRequest)
{
GrpcRequest request = new GrpcRequest
{
ErrorMessage = $"Request nodes failed."
};
Metadata data = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, GetNodesTimeout.ToString()}
};
return RequestAsync(_client, c => c.GetNodesAsync(new NodesRequest { MaxCount = count }, data), request);
}
public async Task<FinalizeConnectReply> FinalizeConnectAsync(Handshake handshake)
{
GrpcRequest request = new GrpcRequest { ErrorMessage = $"Error while finalizing request to {this}." };
Metadata data = new Metadata { {GrpcConstants.TimeoutMetadataKey, FinalizeConnectTimeout.ToString()} };
var finalizeConnectReply = await RequestAsync(_client, c => c.FinalizeConnectAsync(handshake, data), request);
IsConnected = finalizeConnectReply.Success;
return finalizeConnectReply;
}
public async Task<BlockWithTransactions> GetBlockByHashAsync(Hash hash) |
<<<<<<<
@lock = DPoSTxLock;
transactions = _dPoStxs;
=======
return await DPoSTxLock.WriteLock(() => AddDPoSTransaction(tx));
>>>>>>>
return await DPoSTxLock.WriteLock(() => AddDPoSTransaction(tx));
<<<<<<<
var res = pool.EnQueueTx(tx);
if (res == TxValidation.TxInsertionAndBroadcastingError.Success)
{
// add tx
transactions.GetOrAdd(tx.GetHash(), tx);
if(tx.Type == TransactionType.DposTransaction)
_bpAddrs.Add(tx.From);
}
return res;
});
=======
// add tx
_contractTxs.GetOrAdd(tx.GetHash(), tx);
}
return res;
>>>>>>>
// add tx
_contractTxs.GetOrAdd(tx.GetHash(), tx);
}
return res;
<<<<<<<
await @lock.WriteLock(() => { pool.Withdraw(kv.Key, min); });
foreach (var tx in kv.Value)
{
if (transactions.ContainsKey(tx.GetHash()))
continue;
await AddTransaction(tx);
}
=======
>>>>>>>
<<<<<<<
=======
await @lock.WriteLock(() =>
{
pool.Withdraw(kv.Key, min);
foreach (var tx in kv.Value)
{
if (@lock == DPoSTxLock)
{
AddDPoSTransaction(tx);
}
else
{
AddContractTransaction(tx);
}
}
});
>>>>>>>
await @lock.WriteLock(() =>
{
pool.Withdraw(kv.Key, min);
foreach (var tx in kv.Value)
{
if (@lock == DPoSTxLock)
{
AddDPoSTransaction(tx);
}
else
{
AddContractTransaction(tx);
}
}
});
<<<<<<<
=======
_logger?.Log(LogLevel.Debug, "rollbacked {0} txs ...", txsOut.Count);
>>>>>>>
_logger?.Log(LogLevel.Debug, "rollbacked {0} txs ...", txsOut.Count); |
<<<<<<<
if (ChainConfig.Instance.ChainId != GlobalConfig.DefaultChainId)
{
var minersOfTerm1 = await GetMiners(CalculateKey(1));
if (minersOfTerm1 != null && minersOfTerm1.MainchainLatestTermNumber != 0)
{
termNumber = minersOfTerm1.TermNumber;
}
}
Miners miners;
if (termNumber != 0)
{
miners = await GetMiners(CalculateKey(termNumber));
if (miners != null && !miners.IsEmpty())
return miners;
}
=======
var miners = await GetMiners(Key.ToHex());
if (miners != null && miners.PublicKeys.Any())
return miners;
>>>>>>>
if (ChainConfig.Instance.ChainId != GlobalConfig.DefaultChainId)
{
var minersOfTerm1 = await GetMiners(CalculateKey(1));
if (minersOfTerm1 != null && minersOfTerm1.MainchainLatestTermNumber != 0)
{
termNumber = minersOfTerm1.TermNumber;
}
}
Miners miners;
if (termNumber != 0)
{
miners = await GetMiners(CalculateKey(termNumber));
if (miners != null && miners.PublicKeys.Any())
return miners;
} |
<<<<<<<
typeof(CSharpRuntimeAElfModule),
typeof(DatabaseAElfModule)
=======
typeof(CSharpRuntimeAElfModule2),
typeof(DatabaseAElfModule),
typeof(KernelAElfModule)
>>>>>>>
typeof(CSharpRuntimeAElfModule),
typeof(DatabaseAElfModule),
typeof(KernelAElfModule) |
<<<<<<<
if (!IpEndPointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEnpdoint))
=======
if (!IpEndpointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEndpoint))
>>>>>>>
if (!IpEndPointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEndpoint)) |
<<<<<<<
context.SetInstruction(CPUx86.Instruction.PopInstruction, ebx);
=======
// Pop callee's EIP that has been used for instruction handling
ctx.SetInstruction(CPUx86.Instruction.PopInstruction, ebx);
>>>>>>>
// Pop callee's EIP that has been used for instruction handling
context.SetInstruction(CPUx86.Instruction.PopInstruction, ebx);
<<<<<<<
context.AppendInstruction(CPUx86.Instruction.PushInstruction, null, new ConstantOperand(I, (-stackSize) + 0x0C));
=======
// Save callee's EIP to the stack for exception handling
ctx.AppendInstruction(CPUx86.Instruction.PushInstruction, null, new ConstantOperand(I, (-stackSize) + 0x0C));
>>>>>>>
// Save callee's EIP to the stack for exception handling
context.AppendInstruction(CPUx86.Instruction.PushInstruction, null, new ConstantOperand(I, (-stackSize) + 0x0C)); |
<<<<<<<
using AElf.Types;
=======
using AElf.Sdk.CSharp;
>>>>>>>
using AElf.Types;
<<<<<<<
protected DateTime BlockchainStartTime => DateTime.Parse("2019-01-01 00:00:00.000").ToUniversalTime();
protected byte[] TokenContractCoe => Codes.Single(kv => kv.Key.Contains("MultiToken")).Value;
protected byte[] ParliamentAuthCode => Codes.Single(kv => kv.Key.Contains("Parliament")).Value;
protected byte[] DPoSConsensusCode => Codes.Single(kv => kv.Key.Contains("Consensus.AEDPoS")).Value;
=======
protected DateTime BlockchainStartTimestamp => DateTime.Parse("2019-01-01 00:00:00.000").ToUniversalTime();
>>>>>>>
protected DateTime BlockchainStartTime => DateTime.Parse("2019-01-01 00:00:00.000").ToUniversalTime();
protected byte[] TokenContractCoe => Codes.Single(kv => kv.Key.Contains("MultiToken")).Value;
protected byte[] ParliamentAuthCode => Codes.Single(kv => kv.Key.Contains("Parliament")).Value;
protected byte[] DPoSConsensusCode => Codes.Single(kv => kv.Key.Contains("Consensus.AEDPoS")).Value;
protected DateTime BlockchainStartTimestamp => DateTime.Parse("2019-01-01 00:00:00.000").ToUniversalTime();
<<<<<<<
DeploySystemSmartContract(
KernelConstants.CodeCoverageRunnerCategory,
ParliamentAuthCode,
Hash.FromString("AElf.ContractNames.ParliamentAuth"),
DefaultSenderKeyPair
));
=======
BasicContractZeroStub.DeploySystemSmartContract.SendAsync(
new SystemContractDeploymentInput
{
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(ParliamentAuthContract).Assembly.Location)),
Name = Hash.FromString("AElf.ContractNames.ParliamentAuth"),
TransactionMethodCallList = GenerateParliamentAuthInitializationCallList()
})).Output;
>>>>>>>
DeploySystemSmartContract(
KernelConstants.CodeCoverageRunnerCategory,
ParliamentAuthCode,
Hash.FromString("AElf.ContractNames.ParliamentAuth"),
DefaultSenderKeyPair
));
<<<<<<<
AsyncHelper.RunSync(async () => await InitializationParliamentAuth());
=======
>>>>>>>
AsyncHelper.RunSync(async () => await InitializationParliamentAuth());
<<<<<<<
DeployContractAsync(
KernelConstants.CodeCoverageRunnerCategory,
ParliamentAuthCode,
DefaultSenderKeyPair));
OtherParliamentAuthContractStub = GetTester<ParliamentAuthContractContainer.ParliamentAuthContractStub>(otherParliamentAuthContractAddress, DefaultSenderKeyPair);
=======
BasicContractZeroStub.DeploySmartContract.SendAsync(
new ContractDeploymentInput
{
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(ParliamentAuthContract).Assembly.Location)),
})).Output;
OtherParliamentAuthContractStub =
GetTester<ParliamentAuthContractContainer.ParliamentAuthContractStub>(
otherParliamentAuthContractAddress, DefaultSenderKeyPair);
>>>>>>>
DeployContractAsync(
KernelConstants.CodeCoverageRunnerCategory,
ParliamentAuthCode,
DefaultSenderKeyPair));
OtherParliamentAuthContractStub = GetTester<ParliamentAuthContractContainer.ParliamentAuthContractStub>(otherParliamentAuthContractAddress, DefaultSenderKeyPair);
<<<<<<<
AsyncHelper.RunSync(async () => await InitializeToken());
ConsensusContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(
KernelConstants.CodeCoverageRunnerCategory,
DPoSConsensusCode,
ConsensusSmartContractAddressNameProvider.Name,
DefaultSenderKeyPair));
=======
ConsensusContractAddress = AsyncHelper.RunSync(() => GetContractZeroTester(DefaultSenderKeyPair)
.DeploySystemSmartContract.SendAsync(new SystemContractDeploymentInput
{
Category = KernelConstants.CodeCoverageRunnerCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(AEDPoSContract).Assembly.Location)),
Name = ConsensusSmartContractAddressNameProvider.Name,
TransactionMethodCallList = GenerateConsensusInitializationCallList()
})).Output;
>>>>>>>
AsyncHelper.RunSync(async () => await InitializeToken());
ConsensusContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(
KernelConstants.CodeCoverageRunnerCategory,
DPoSConsensusCode,
ConsensusSmartContractAddressNameProvider.Name,
DefaultSenderKeyPair));
<<<<<<<
internal ACS0Container.ACS0Stub GetContractZeroTester(ECKeyPair keyPair)
=======
internal BasicContractZeroContainer.BasicContractZeroStub GetContractZeroTester(ECKeyPair keyPair)
>>>>>>>
internal ACS0Container.ACS0Stub GetContractZeroTester(ECKeyPair keyPair)
<<<<<<<
=======
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList
GenerateParliamentAuthInitializationCallList()
{
var parliamentMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
parliamentMethodCallList.Add(nameof(ParliamentAuthContract.Initialize),
new ParliamentAuthInitializationInput
{
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name
});
>>>>>>>
<<<<<<<
private async Task InitializeToken()
=======
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList
GenerateTokenInitializationCallList()
>>>>>>>
private async Task InitializeToken() |
<<<<<<<
=======
using AElf.Contracts.Consensus.AEDPoS;
using AElf.Contracts.Genesis;
>>>>>>>
using AElf.Contracts.Consensus.AEDPoS;
<<<<<<<
internal Acs4.ACS4Container.ACS4ReferenceState ConsensusContract {get; set; }
internal Acs0.ACS0Container.ACS0ReferenceState BasicContractZero { get; set; }
=======
internal AEDPoSContractContainer.AEDPoSContractReferenceState ConsensusContract {get; set; }
internal BasicContractZeroContainer.BasicContractZeroReferenceState BasicContractZero { get; set; }
>>>>>>>
internal AEDPoSContractContainer.AEDPoSContractReferenceState ConsensusContract {get; set; }
internal Acs0.ACS0Container.ACS0ReferenceState BasicContractZero { get; set; } |
<<<<<<<
using AElf.Miner.EventMessages;
using AElf.Miner.Rpc.Client;
using AElf.Miner.TxMemPool;
using Easy.MessageHub;
=======
>>>>>>>
using AElf.Miner.EventMessages;
using AElf.Miner.TxMemPool;
using Easy.MessageHub;
<<<<<<<
public BlockExecutor(IChainService chainService, IExecutingService executingService,
ITransactionResultManager transactionResultManager, ClientManager clientManager,
IBinaryMerkleTreeManager binaryMerkleTreeManager, TxHub txHub)
=======
public BlockExecutor(IChainService chainService, IExecutingService executingService,
ITransactionManager transactionManager, ITransactionResultManager transactionResultManager,
ClientManager clientManager, IBinaryMerkleTreeManager binaryMerkleTreeManager)
>>>>>>>
public BlockExecutor(IChainService chainService, IExecutingService executingService,
ITransactionResultManager transactionResultManager, ClientManager clientManager,
IBinaryMerkleTreeManager binaryMerkleTreeManager, TxHub txHub)
<<<<<<<
_txHub = txHub;
_logger = LogManager.GetLogger(nameof(BlockExecutor));
=======
_logger = LogManager.GetLogger(nameof(BlockExecutor));
>>>>>>>
_txHub = txHub;
_logger = LogManager.GetLogger(nameof(BlockExecutor));
<<<<<<<
_logger?.Trace($"Executing block {block.GetHash()}");
=======
>>>>>>>
_logger?.Trace($"Executing block {block.GetHash()}");
<<<<<<<
=======
>>>>>>>
<<<<<<<
private async Task<List<TransactionResult>> ExecuteTransactions(List<Transaction> readyTxs, Hash chainId,
Hash disambiguationHash)
=======
private async Task<List<TransactionResult>> ExecuteTransactions(List<Transaction> readyTxs, IBlock block,
Hash disambiguationHash)
>>>>>>>
private async Task<List<TransactionResult>> ExecuteTransactions(List<Transaction> readyTxs, Hash chainId,
Hash disambiguationHash)
<<<<<<<
: await _executingService.ExecuteAsync(readyTxs, chainId, Cts.Token, disambiguationHash);
=======
: await _executingService.ExecuteAsync(readyTxs, block.Header.ChainId, Cts.Token, disambiguationHash);
>>>>>>>
: await _executingService.ExecuteAsync(readyTxs, chainId, Cts.Token, disambiguationHash);
<<<<<<<
=======
>>>>>>>
<<<<<<<
if (!res)
_logger?.Warn(errlog);
=======
if (res.IsFailed())
_logger?.Warn(errorLog);
>>>>>>>
if (res.IsFailed())
_logger?.Warn(errorLog);
<<<<<<<
if (!res)
throw new InvalidBlockException(errlog);
=======
return res;
>>>>>>>
return res;
<<<<<<<
MessageHub.Instance.Publish(new TransactionsExecuted(executedTxs, bn));
=======
foreach (var t in executedTxs)
{
await _transactionManager.AddTransactionAsync(t);
}
>>>>>>>
MessageHub.Instance.Publish(new TransactionsExecuted(executedTxs, bn));
<<<<<<<
=======
>>>>>>> |
<<<<<<<
var client = await _grpcCrossChainClientProvider.TryGetClient(remoteChainId);
Assert.NotNull(client);
=======
var client = await _grpcCrossChainClientProvider.GetClientAsync(remoteChainId);
Assert.True(client.RemoteChainId == remoteChainId);
Assert.True(client.TargetUriString.Equals("localhost:5000"));
Assert.True(client.IsConnected);
>>>>>>>
var client = await _grpcCrossChainClientProvider.TryGetClient(remoteChainId);
Assert.True(client.RemoteChainId == remoteChainId);
Assert.True(client.TargetUriString.Equals("localhost:5000"));
Assert.True(client.IsConnected);
<<<<<<<
var client = _grpcCrossChainClientService.RequestChainInitializationData(chainId);
await client.RequestChainInitializationDataAsync(chainId);
=======
var client = _grpcCrossChainClientService.CreateClientForChainInitializationData(chainId);
await client.ConnectAsync();
var res = await client.RequestChainInitializationDataAsync(chainId);
Assert.True(res.CreationHeightOnParentChain == 1);
>>>>>>>
var res = await _grpcCrossChainClientService.RequestChainInitializationData(chainId);
Assert.True(res.CreationHeightOnParentChain == 1); |
<<<<<<<
using AElf.Miner.Miner;
using AElf.Runtime.CSharp;
using AElf.SmartContract;
=======
using AElf.Miner.Rpc.Server;
>>>>>>>
using AElf.Runtime.CSharp;
using AElf.SmartContract;
<<<<<<<
using AElf.Configuration.Config.Chain;
using AElf.Crosschain.Grpc.Client;
using AElf.Crosschain.Grpc.Server;
using AElf.Crosschain.Server;
=======
>>>>>>>
using AElf.Crosschain.Grpc.Client;
using AElf.Crosschain.Grpc.Server;
<<<<<<<
using AElf.Miner.TxMemPool;
=======
using AElf.Kernel.Services;
using AElf.Miner.Rpc.Client;
>>>>>>>
using AElf.Kernel.Services; |
<<<<<<<
long lockedTokenAmount = 10;
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty);
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
=======
long lockedTokenAmount = 10;
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
{
sideChainCreationRequest.LockedTokenAmount = 0;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, CrossChainConsts.RequestChainCreationMethodName,
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
{
sideChainCreationRequest.LockedTokenAmount = 1;
sideChainCreationRequest.IndexingPrice = 2;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, CrossChainConsts.RequestChainCreationMethodName,
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
{
sideChainCreationRequest.LockedTokenAmount = 10;
sideChainCreationRequest.IndexingPrice = 1;
sideChainCreationRequest.ContractCode = ByteString.Empty;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, CrossChainConsts.RequestChainCreationMethodName,
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
>>>>>>>
long lockedTokenAmount = 10;
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
{
sideChainCreationRequest.LockedTokenAmount = 0;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
{
sideChainCreationRequest.LockedTokenAmount = 1;
sideChainCreationRequest.IndexingPrice = 2;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
{
sideChainCreationRequest.LockedTokenAmount = 10;
sideChainCreationRequest.IndexingPrice = 1;
sideChainCreationRequest.ContractCode = ByteString.Empty;
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Invalid chain creation request."));
}
<<<<<<<
=======
//TODO: Disable for param packer removing
// [Fact]
// public async Task Create_SideChain_FireEvent()
// {
// long lockedTokenAmount = 10;
// await InitializeCrossChainContract();
// await ApproveBalance(lockedTokenAmount);
//
// var sideChainInfo = new SideChainInfo
// {
// SideChainStatus = SideChainStatus.Apply,
// ContractCode = ByteString.CopyFromUtf8("Test"),
// IndexingPrice = 1,
// Proposer = CrossChainContractTestHelper.GetAddress(),
// LockedTokenAmount = lockedTokenAmount
// };
//
// var tx = await GenerateTransactionAsync(CrossChainContractAddress, CrossChainConsts.RequestChainCreationMethodName, null,
// sideChainInfo);
// await MineAsync(new List<Transaction> {tx});
// var txRes = await GetTransactionResult(tx.GetHash());
// var chainId = ChainHelpers.GetChainId(1);
// var txResult =
// await ExecuteContractWithMiningAsync(CrossChainContractAddress,
// nameof(CrossChainContract.CreateSideChain),
// new SInt32Value()
// {
// Value = chainId
// });
// Assert.True(txResult.Status == TransactionResultStatus.Mined);
// object[] data = ParamsPacker.Unpack(txResult.Logs.First().Data.ToByteArray(),
// new[] {typeof(Address), typeof(int)});
// var actualChainId = (int) data[1];
// var actualSender = (Address) data[0];
// Assert.True(chainId == actualChainId);
// Assert.Equal(CrossChainContractTestHelper.GetAddress(), actualSender);
// }
>>>>>>>
<<<<<<<
var sideChainCreationRequest = CreateSideChainCreationRequest(1, 0, ByteString.Empty);
var tx = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null,
sideChainCreationRequest);
await MineAsync(new List<Transaction> {tx});
var chainId = ChainHelpers.GetChainId(2);
var txResult =
=======
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var txResult = await Tester.ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest);
var chainId = RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId;
var transactionResult =
>>>>>>>
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var txResult = await Tester.ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation), sideChainCreationRequest);
var chainId = RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId;
var transactionResult = |
<<<<<<<
using AElf.Kernel.Manager.Interfaces;
using AElf.Kernel.EventMessages;
=======
using AElf.Kernel.Managers;
using AElf.Kernel.Storages;
using AElf.Kernel.Types.Transaction;
>>>>>>>
using AElf.Kernel.EventMessages;
using AElf.Kernel.Managers;
using AElf.Kernel.Storages;
using AElf.Kernel.Types.Transaction; |
<<<<<<<
using AElf.Contracts.Association;
=======
using AElf.Contracts.Configuration;
>>>>>>>
using AElf.Contracts.Association;
using AElf.Contracts.Configuration; |
<<<<<<<
=======
using AElf.Miner.Rpc.Client;
using AElf.Miner.Rpc.Server;
>>>>>>>
<<<<<<<
minerConfig.ChainId = new Hash()
{
Value = ByteString.CopyFrom(ChainConfig.Instance.ChainId.DecodeBase58())
};
builder.RegisterModule(new CrosschainAutofacModule());
builder.RegisterType<ClientManager>().SingleInstance().OnActivated(mc =>
{
mc.Instance.Init(dir: ApplicationHelpers.ConfigPath);
}
);
builder.RegisterType<ServerManager>().SingleInstance().OnActivated(mc =>
{
mc.Instance.Init(ApplicationHelpers.ConfigPath);
}
);
builder.RegisterModule(new MinerAutofacModule(minerConfig));
=======
minerConfig.ChainId = ChainConfig.Instance.ChainId.ConvertBase58ToChainId();
var services = context.Services;
>>>>>>>
minerConfig.ChainId = ChainConfig.Instance.ChainId.ConvertBase58ToChainId();
var services = context.Services; |
<<<<<<<
using AElf.Kernel.TxMemPool;
=======
using AElf.Kernel.Storages;
>>>>>>>
using AElf.Kernel.TxMemPool;
using AElf.Kernel.Storages; |
<<<<<<<
.AddSingleton<IBlocksExecutionSucceededLogEventProcessor, IrreversibleBlockHeightUnacceptableLogEventProcessor>();
context.Services.AddSingleton<IBlocksExecutionSucceededLogEventProcessor, SecretSharingInformationLogEventProcessor>();
context.Services.AddSingleton<IChargeFeeStrategy, ConsensusContractChargeFeeStrategy>();
=======
.AddSingleton<IBestChainFoundLogEventProcessor, IrreversibleBlockHeightUnacceptableLogEventProcessor>();
context.Services.AddSingleton<IBestChainFoundLogEventProcessor, SecretSharingInformationLogEventProcessor>();
>>>>>>>
.AddSingleton<IBlocksExecutionSucceededLogEventProcessor, IrreversibleBlockHeightUnacceptableLogEventProcessor>();
context.Services.AddSingleton<IBlocksExecutionSucceededLogEventProcessor, SecretSharingInformationLogEventProcessor>(); |
<<<<<<<
using AElf.ChainControllerImpl.TxMemPool;
=======
using AElf.Execution;
using AElf.Execution.Scheduling;
>>>>>>>
using AElf.ChainControllerImpl.TxMemPool;
using AElf.Execution;
using AElf.Execution.Scheduling; |
<<<<<<<
private readonly EconomicOptions _economicOptions;
=======
private readonly TokenInitialOptions _tokenInitialOptions;
private readonly ContractOptions _contractOptions;
>>>>>>>
private readonly EconomicOptions _economicOptions;
private readonly ContractOptions _contractOptions;
<<<<<<<
IOptionsSnapshot<EconomicOptions> economicOptions)
=======
IOptionsSnapshot<TokenInitialOptions> tokenInitialOptions, IOptionsSnapshot<ContractOptions> contractOptions)
>>>>>>>
IOptionsSnapshot<EconomicOptions> economicOptions, IOptionsSnapshot<ContractOptions> contractOptions)
<<<<<<<
_economicOptions = economicOptions.Value;
=======
_tokenInitialOptions = tokenInitialOptions.Value;
_contractOptions = contractOptions.Value;
>>>>>>>
_economicOptions = economicOptions.Value;
_contractOptions = contractOptions.Value; |
<<<<<<<
=======
void InformRollback(ulong targetHeight, ulong currentHeight);
bool IsFull();
>>>>>>>
bool IsFull(); |
<<<<<<<
using AElf.Miner.Miner;
=======
using AElf.Execution.Scheduling;
>>>>>>>
using AElf.Miner.Miner;
using AElf.Execution.Scheduling; |
<<<<<<<
using System;
using System.Threading.Tasks;
using AElf.Network.Data;
=======
using System.Threading.Tasks;
using AElf.Network;
>>>>>>>
using System;
using System.Threading.Tasks;
using AElf.Network.Data;
using System.Threading.Tasks;
using AElf.Network;
<<<<<<<
[JsonRpcMethod("add_peer", "address")]
public async Task<JObject> AddPeer(string address)
{
NodeData nodeData = null;
try
{
nodeData = NodeData.FromString(address);
}
catch { }
if (nodeData == null)
{
throw new JsonRpcServiceException(-32602, "Invalid address");
}
await Task.Run(() => Manager.AddPeer(nodeData));
return new JObject { ["result"] = true };
}
[JsonRpcMethod("remove_peer", "address")]
public async Task<JObject> RemovePeer(string address)
{
NodeData nodeData = null;
try
{
nodeData = NodeData.FromString(address);
}
catch { }
if (nodeData == null)
{
throw new JsonRpcServiceException(-32602, "Invalid address");
}
await Task.Run(() => Manager.RemovePeer(nodeData));
return new JObject { ["result"] = true };
}
=======
[JsonRpcMethod("get_pool_state")]
public async Task<JObject> GetPoolState()
{
var pendingRequestCount = NetworkManager.GetPendingRequestCount();
var jobQueueCount = BlockSynchronizer.GetJobQueueCount();
var response = new JObject
{
["RequestPoolSize"] = pendingRequestCount,
["ReceivePoolSize"] = jobQueueCount
};
return JObject.FromObject(response);
}
>>>>>>>
[JsonRpcMethod("add_peer", "address")]
public async Task<JObject> AddPeer(string address)
{
NodeData nodeData = null;
try
{
nodeData = NodeData.FromString(address);
}
catch { }
if (nodeData == null)
{
throw new JsonRpcServiceException(-32602, "Invalid address");
}
await Task.Run(() => Manager.AddPeer(nodeData));
return new JObject { ["result"] = true };
}
[JsonRpcMethod("remove_peer", "address")]
public async Task<JObject> RemovePeer(string address)
{
NodeData nodeData = null;
try
{
nodeData = NodeData.FromString(address);
}
catch { }
if (nodeData == null)
{
throw new JsonRpcServiceException(-32602, "Invalid address");
}
await Task.Run(() => Manager.RemovePeer(nodeData));
return new JObject { ["result"] = true };
}
[JsonRpcMethod("get_pool_state")]
public async Task<JObject> GetPoolState()
{
var pendingRequestCount = NetworkManager.GetPendingRequestCount();
var jobQueueCount = BlockSynchronizer.GetJobQueueCount();
var response = new JObject
{
["RequestPoolSize"] = pendingRequestCount,
["ReceivePoolSize"] = jobQueueCount
};
return JObject.FromObject(response);
} |
<<<<<<<
if (tx.RefBlockNumber > chain.LongestChainHeight + NetworkConstants.DefaultMinBlockGapBeforeSync)
return;
=======
if (tx.RefBlockNumber > chain.LongestChainHeight + NetworkConstants.DefaultInitialSyncOffset)
return new VoidReply();
_ = EventBus.PublishAsync(new TransactionsReceivedEvent { Transactions = new List<Transaction> {tx} });
>>>>>>>
if (tx.RefBlockNumber > chain.LongestChainHeight + NetworkConstants.DefaultInitialSyncOffset)
return; |
<<<<<<<
public IEnumerable<FileDescriptor> GetFileDescriptors()
{
var descriptor = Descriptors.Last();
return GetSelfAndDependency(descriptor.File);
}
=======
public Hash ContractHash { get; set; }
>>>>>>>
public IEnumerable<FileDescriptor> GetFileDescriptors()
{
var descriptor = Descriptors.Last();
return GetSelfAndDependency(descriptor.File);
}
public Hash ContractHash { get; set; } |
<<<<<<<
var auditor = new ContractAuditor();
auditor.Audit(code, new RequiredAcsDto
=======
var auditor = new CSharpContractAuditor(null, null);
auditor.Audit(code, new RequiredAcs
>>>>>>>
var auditor = new ContractAuditor();
auditor.Audit(code, new RequiredAcs |
<<<<<<<
=======
public IContainer ApplicationContainer { get; private set; }
>>>>>>>
<<<<<<<
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info { Title = "AElf API", Version = "v1" });
});
services.AddApplication<ManagementWebsiteAElfModule>(options =>
{
options.UseAutofac();
});
=======
services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info {Title = "AElf API", Version = "v1"}); });
var builder = new ContainerBuilder();
builder.RegisterModule(new LoggerAutofacModule());
builder.RegisterType<SideChainService>().As<ISideChainService>().SingleInstance();
builder.RegisterType<ChainService>().As<IChainService>().SingleInstance();
builder.RegisterType<WorkerService>().As<IWorkerService>().SingleInstance();
builder.RegisterType<LighthouseService>().As<ILighthouseService>().SingleInstance();
builder.RegisterType<LauncherService>().As<ILauncherService>().SingleInstance();
builder.RegisterType<AkkaService>().As<IAkkaService>().SingleInstance();
builder.RegisterType<TransactionService>().As<ITransactionService>().SingleInstance();
builder.RegisterType<NodeService>().As<INodeService>().SingleInstance();
builder.RegisterType<NetworkService>().As<INetworkService>().SingleInstance();
builder.RegisterType<RecordService>().As<IRecordService>().SingleInstance();
builder.Populate(services);
var ApplicationContainer = builder.Build();
ApplicationContainer.Resolve<IRecordService>().Start();
>>>>>>>
services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info {Title = "AElf API", Version = "v1"}); });
services.AddApplication<ManagementWebsiteAElfModule>(options =>
{
options.UseAutofac();
}); |
<<<<<<<
Logger=NullLogger<MockSetup>.Instance;
_dataStore = dataStore;
_stateStore = stateStore;
_smartContractManager = new SmartContractManager(_dataStore);
_transactionManager = new TransactionManager(_dataStore);
_transactionTraceManager = new TransactionTraceManager(_dataStore);
_transactionResultManager = new TransactionResultManager(_dataStore);
=======
_stateManager = stateManager;
_transactionManager = transactionManager;
_functionMetadataManager = functionMetadataManager;
_smartContractManager = smartContractManager;
_transactionTraceManager = transactionTraceManager;
_transactionResultManager = transactionResultManager;
>>>>>>>
Logger=NullLogger<MockSetup>.Instance;
_stateManager = stateManager;
_transactionManager = transactionManager;
_functionMetadataManager = functionMetadataManager;
_smartContractManager = smartContractManager;
_transactionTraceManager = transactionTraceManager;
_transactionResultManager = transactionResultManager;
<<<<<<<
_functionMetadataService = new FunctionMetadataService(_dataStore);
=======
_functionMetadataService = new FunctionMetadataService(_logger,_functionMetadataManager);
>>>>>>>
_functionMetadataService = new FunctionMetadataService(_functionMetadataManager); |
<<<<<<<
public MockSetup(IStateManager stateManager, IChainCreationService chainCreationService,
IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerFactory smartContractRunnerFactory
, ISmartContractManager smartContractManager)
=======
public MockSetup(IStateStore stateStore, IChainCreationService chainCreationService,
IDataStore dataStore, IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerContainer smartContractRunnerContainer)
>>>>>>>
public MockSetup(IStateManager stateManager, IChainCreationService chainCreationService,
IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerContainer smartContractRunnerContainer
, ISmartContractManager smartContractManager)
<<<<<<<
_smartContractRunnerFactory = smartContractRunnerFactory;
SmartContractManager = smartContractManager;
=======
_smartContractRunnerContainer = smartContractRunnerContainer;
SmartContractManager = new SmartContractManager(dataStore);
>>>>>>>
_smartContractRunnerContainer = smartContractRunnerContainer;
SmartContractManager = smartContractManager;
<<<<<<<
SmartContractService = new SmartContractService(SmartContractManager, _smartContractRunnerFactory,
StateManager, _functionMetadataService);
=======
SmartContractService = new SmartContractService(SmartContractManager, _smartContractRunnerContainer,
stateStore, _functionMetadataService);
>>>>>>>
SmartContractService = new SmartContractService(SmartContractManager, _smartContractRunnerContainer,
StateManager, _functionMetadataService); |
<<<<<<<
using Microsoft.Extensions.DependencyInjection;
=======
using AElf.WebApp.Application.Chain.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
>>>>>>>
using AElf.WebApp.Application.Chain.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
<<<<<<<
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddAutoMapperObjectMapper<ChainApplicationWebAppAElfModule>();
Configure<AbpAutoMapperOptions>(options =>
{
options.AddMaps<ChainApplicationWebAppAElfModule>(true);
});
}
=======
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services
.AddSingleton<ITransactionResultStatusCacheProvider, TransactionResultStatusCacheProvider>();
}
>>>>>>>
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddAutoMapperObjectMapper<ChainApplicationWebAppAElfModule>();
Configure<AbpAutoMapperOptions>(options =>
{
options.AddMaps<ChainApplicationWebAppAElfModule>(true);
});
context.Services
.AddSingleton<ITransactionResultStatusCacheProvider, TransactionResultStatusCacheProvider>();
} |
<<<<<<<
[Fact]
public async Task SetSymbolsToPayTxSizeFee_With_Invalid_Weight_Test()
=======
[Fact(DisplayName = "[MultiToken] validate the input")]
public async Task SetSymbolsToPayTxSizeFee_With_Invalid_Input_Test()
>>>>>>>
[Fact]
public async Task SetSymbolsToPayTxSizeFee_With_Invalid_Weight_Test()
<<<<<<<
TokenSymbol = primaryTokenSymbol,
AddedTokenWeight = 2,
BaseTokenWeight = 1
});
await VerifyTheInvalidSymbolList(theDefaultController, newSymbolList);
=======
var newSymbolList = new SymbolListToPayTxSizeFee();
newSymbolList.SymbolsToPayTxSizeFee.Add(new SymbolToPayTxSizeFee
{
TokenSymbol = primaryTokenSymbol,
AddedTokenWeight = 2,
BaseTokenWeight = 1
});
var result = await VerifyTheSymbolList(theDefaultController, newSymbolList);
result.ShouldBe(false);
}
>>>>>>>
TokenSymbol = primaryTokenSymbol,
AddedTokenWeight = 2,
BaseTokenWeight = 1
});
var result = await VerifyTheSymbolList(theDefaultController, newSymbolList);
result.ShouldBe(false);
<<<<<<<
}
};
await VerifyTheInvalidSymbolList(theDefaultController, newSymbolList);
}
[Fact]
public async Task SetSymbolsToPayTxSizeFee_Without_PrimaryToken_Test()
{
var theDefaultController = await GetDefaultParliamentAddressAsync();
var feeToken = "FEETOKEN";
await TokenContractStub.Create.SendAsync(new CreateInput
=======
};
var result = await VerifyTheSymbolList(theDefaultController, newSymbolList);
result.ShouldBe(false);
}
// include invalid weright
>>>>>>>
}
};
var result = await VerifyTheSymbolList(theDefaultController, newSymbolList);
result.ShouldBe(false);
}
[Fact]
public async Task SetSymbolsToPayTxSizeFee_Without_PrimaryToken_Test()
{
var theDefaultController = await GetDefaultParliamentAddressAsync();
var feeToken = "FEETOKEN";
await TokenContractStub.Create.SendAsync(new CreateInput |
<<<<<<<
using AElf.Common.Extensions;
using AElf.Kernel.Manager.Interfaces;
using AElf.Kernel.SmartContract;
using AElf.Kernel.Storage.Interfaces;
=======
using AElf.Kernel.Storages;
>>>>>>>
using AElf.Kernel.Manager.Interfaces;
using AElf.Kernel.SmartContract;
<<<<<<<
=======
#pragma warning disable CS0169,CS0649
>>>>>>>
#pragma warning disable CS0169,CS0649 |
<<<<<<<
internal DividendPoolContractContainer.DividendPoolContractReferenceState DividendPoolContract{ get; set; }
=======
internal AEDPoSContractContainer.AEDPoSContractReferenceState ConsensusContract { get; set; }
>>>>>>>
internal AEDPoSContractContainer.AEDPoSContractReferenceState ConsensusContract { get; set; }
internal DividendPoolContractContainer.DividendPoolContractReferenceState DividendPoolContract{ get; set; } |
<<<<<<<
using System;
using System.Collections.Generic;
=======
using System;
>>>>>>>
using System;
using System.Collections.Generic;
<<<<<<<
=======
>>>>>>>
<<<<<<<
public void EnqueueBlock_ShouldExecuteCallback_Test()
=======
public void EnqueueBlock_ShouldExecuteCallback()
{
AutoResetEvent executed = new AutoResetEvent(false);
NetworkException exception = null;
bool called = false;
_nonInterceptedPeer.EnqueueBlock(new BlockWithTransactions(), ex =>
{
exception = ex;
called = true;
executed.Set();
});
executed.WaitOne(TimeSpan.FromMilliseconds(1000));
exception.ShouldBeNull();
called.ShouldBeTrue();
}
[Fact]
public void EnqueueTransaction_ShouldExecuteCallback()
{
AutoResetEvent executed = new AutoResetEvent(false);
NetworkException exception = null;
bool called = false;
_nonInterceptedPeer.EnqueueTransaction(new Transaction(), ex =>
{
exception = ex;
called = true;
executed.Set();
});
executed.WaitOne(TimeSpan.FromMilliseconds(1000));
exception.ShouldBeNull();
called.ShouldBeTrue();
}
[Fact]
public void EnqueueAnnouncement_ShouldExecuteCallback()
{
AutoResetEvent executed = new AutoResetEvent(false);
NetworkException exception = null;
bool called = false;
_nonInterceptedPeer.EnqueueAnnouncement(new BlockAnnouncement(), ex =>
{
exception = ex;
called = true;
executed.Set();
});
executed.WaitOne(TimeSpan.FromMilliseconds(1000));
exception.ShouldBeNull();
called.ShouldBeTrue();
}
[Fact]
public async Task RequestBlockAsync_Success()
>>>>>>>
public void EnqueueBlock_ShouldExecuteCallback_Test() |
<<<<<<<
using AElf.Kernel.Blockchain.Infrastructure;
using AElf.Kernel.ChainController;
using AElf.Kernel.Infrastructure;
using AElf.Kernel.SmartContract;
using AElf.Kernel.SmartContractExecution.Infrastructure;
using AElf.Kernel.TransactionPool;
=======
using AElf.Kernel.Services;
using AElf.Kernel.Storages;
>>>>>>>
using AElf.Kernel.Services;
using AElf.Kernel.Blockchain.Infrastructure;
using AElf.Kernel.ChainController;
using AElf.Kernel.Infrastructure;
using AElf.Kernel.SmartContract;
using AElf.Kernel.SmartContractExecution.Infrastructure;
using AElf.Kernel.TransactionPool;
<<<<<<<
=======
public override void PreConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddConventionalRegistrar(new AElfKernelConventionalRegistrar());
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var configuration = context.Services.GetConfiguration();
// TODO : Maybe it shouldn't be set here
Configure<ChainOptions>(configuration);
//Configure<DbConnectionOptions>(configuration);
var services = context.Services;
services.AddAssemblyOf<KernelAElfModule>();
services.AddTransient<IByteSerializer, AElf.Common.Serializers.ProtobufSerializer>();
services.AddTransient(
typeof(IEqualityIndex<>),
typeof(EqualityIndex<,>));
services.AddSingleton<IMinerService, MinerService>();
services.AddTransient(
typeof(IComparisionIndex<>),
typeof(ComparisionIndex<,>));
services.AddTransient(typeof(IStateStore<>), typeof(StateStore<>));
services.AddTransient(typeof(IBlockchainStore<>), typeof(BlockchainStore<>));
services.AddKeyValueDbContext<BlockchainKeyValueDbContext>(p => p.UseRedisDatabase());
services.AddKeyValueDbContext<StateKeyValueDbContext>(p => p.UseRedisDatabase());
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
//TODO! change log output
var loggerFactory = context.ServiceProvider.GetService<ILoggerFactory>();
//loggerFactory.AddNLog();
//builder.RegisterModule(new LoggerAutofacModule("aelf-node-" + NetworkConfig.Instance.ListeningPort));
}
>>>>>>> |
<<<<<<<
context.Services.AddSingleton(typeof(ContractEventDiscoveryService<>));
=======
context.Services
.AddSingleton<IConstrainedTransactionValidationProvider,
ConstrainedAEDPoSTransactionValidationProvider>();
>>>>>>>
context.Services
.AddSingleton<IConstrainedTransactionValidationProvider,
ConstrainedAEDPoSTransactionValidationProvider>();
context.Services.AddSingleton(typeof(ContractEventDiscoveryService<>)); |
<<<<<<<
using System.Collections.Generic;
using System.Text;
=======
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
>>>>>>>
using System.Collections.Generic;
using System.Text;
<<<<<<<
private Akka.Configuration.Config InitActorConfig(string content)
{
if (ActorConfig.Instance.Seeds == null || ActorConfig.Instance.Seeds.Count == 0)
{
ActorConfig.Instance.Seeds = new List<SeedNode> {new SeedNode {HostName = ActorConfig.Instance.HostName, Port = ActorConfig.Instance.Port}};
}
var seedNodes = new StringBuilder();
seedNodes.Append("akka.cluster.seed-nodes = [");
foreach (var seed in ActorConfig.Instance.Seeds)
{
seedNodes.Append("\"akka.tcp://").Append(SystemName).Append("@").Append(seed.HostName).Append(":").Append(seed.Port).Append("\",");
}
seedNodes.Remove(seedNodes.Length - 1, 1);
seedNodes.Append("]");
var config = ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.hostname=" + ActorConfig.Instance.HostName)
.WithFallback(ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.port=" + ActorConfig.Instance.Port))
.WithFallback(ConfigurationFactory.ParseString(seedNodes.ToString()))
.WithFallback(content);
return config;
}
=======
private Config InitActorConfig(string content)
{
if (ActorConfig.Instance.Seeds == null || ActorConfig.Instance.Seeds.Count == 0)
{
ActorConfig.Instance.Seeds = new List<SeedNode> {new SeedNode {HostName = ActorConfig.Instance.HostName, Port = ActorConfig.Instance.Port}};
}
var seedNodes = new StringBuilder();
seedNodes.Append("akka.cluster.seed-nodes = [");
foreach (var seed in ActorConfig.Instance.Seeds)
{
seedNodes.Append("\"akka.tcp://").Append(SystemName).Append("@").Append(seed.HostName).Append(":").Append(seed.Port).Append("\",");
}
seedNodes.Remove(seedNodes.Length - 1, 1);
seedNodes.Append("]");
var config = ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.hostname=" + ActorConfig.Instance.HostName)
.WithFallback(ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.port=" + ActorConfig.Instance.Port))
.WithFallback(ConfigurationFactory.ParseString(seedNodes.ToString()))
.WithFallback(content);
return config;
}
>>>>>>>
private Akka.Configuration.Config InitActorConfig(string content)
{
if (ActorConfig.Instance.Seeds == null || ActorConfig.Instance.Seeds.Count == 0)
{
ActorConfig.Instance.Seeds = new List<SeedNode> {new SeedNode {HostName = ActorConfig.Instance.HostName, Port = ActorConfig.Instance.Port}};
}
var seedNodes = new StringBuilder();
seedNodes.Append("akka.cluster.seed-nodes = [");
foreach (var seed in ActorConfig.Instance.Seeds)
{
seedNodes.Append("\"akka.tcp://").Append(SystemName).Append("@").Append(seed.HostName).Append(":").Append(seed.Port).Append("\",");
}
seedNodes.Remove(seedNodes.Length - 1, 1);
seedNodes.Append("]");
var config = ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.hostname=" + ActorConfig.Instance.HostName)
.WithFallback(ConfigurationFactory.ParseString("akka.remote.dot-netty.tcp.port=" + ActorConfig.Instance.Port))
.WithFallback(ConfigurationFactory.ParseString(seedNodes.ToString()))
.WithFallback(content);
return config;
} |
<<<<<<<
using AElf.Common;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
=======
using NLog;
>>>>>>>
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
<<<<<<<
var txs = new List<Transaction>();
for (var i = currentHeight - 1; i >= specificHeight; i--)
{
var rollBackBlockHash =
await _dataStore.GetAsync<Hash>(
DataPath.CalculatePointerForGettingBlockHashByHeight(chainId, i));
var header = await _dataStore.GetAsync<BlockHeader>(rollBackBlockHash);
var body = await _dataStore.GetAsync<BlockBody>(
Hash.Xor(
header.GetHash(),header.MerkleTreeRootOfTransactions));
foreach (var txId in body.Transactions)
{
var tx = await _dataStore.GetAsync<Transaction>(txId);
if (tx == null)
{
Logger.LogTrace($"tx {txId} is null.");
}
txs.Add(tx);
await _dataStore.RemoveAsync<Transaction>(txId);
}
Logger.LogTrace($"Rollback block hash: {rollBackBlockHash.Value.ToByteArray().ToHex()}");
}
return txs;
=======
return txId.ToHex();
>>>>>>>
return txId.ToHex(); |
<<<<<<<
public const long MiningRewardPerBlock = 12500000;
=======
public const int MinMinersCount = 9;
>>>>>>>
public const long MiningRewardPerBlock = 12500000;
public const int MinMinersCount = 9; |
<<<<<<<
using System.Collections.Generic;
using AElf.Contracts.CrossChain;
=======
>>>>>>>
using AElf.Contracts.CrossChain; |
<<<<<<<
public ILogger<MinersManager> Logger { get; set; }
private static Hash Key => Hash.FromRawBytes(GlobalConfig.AElfDPoSMinersString.CalculateHash());
=======
private readonly ILogger _logger = LogManager.GetLogger(nameof(MinersManager));
>>>>>>>
public ILogger<MinersManager> Logger { get; set; } |
<<<<<<<
=======
// public static void AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts,
// Hash name = null, SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = null)
// {
// // TODO: Change this
// genesisSmartContracts.AddGenesisSmartContract(typeof(T), name, systemTransactionMethodCallList);
// }
>>>>>>>
// public static void AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts,
// Hash name = null, SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = null)
// {
// // TODO: Change this
// genesisSmartContracts.AddGenesisSmartContract(typeof(T), name, systemTransactionMethodCallList);
// }
<<<<<<<
=======
// public static void AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts,
// Hash name, Action<SystemContractDeploymentInput.Types.SystemTransactionMethodCallList> action)
// {
// SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
//
// action?.Invoke(systemTransactionMethodCallList);
//
// genesisSmartContracts.AddGenesisSmartContract<T>(name, systemTransactionMethodCallList);
// }
>>>>>>>
// public static void AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts,
// Hash name, Action<SystemContractDeploymentInput.Types.SystemTransactionMethodCallList> action)
// {
// SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
//
// action?.Invoke(systemTransactionMethodCallList);
//
// genesisSmartContracts.AddGenesisSmartContract<T>(name, systemTransactionMethodCallList);
// }
<<<<<<<
private Transaction GetTransactionForContractZeroInitialization(ContractZeroInitializationInput contractZeroInitializationInput)
{
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
return new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ISmartContractZero.Initialize),
Params = contractZeroInitializationInput.ToByteString()
};
}
=======
>>>>>>>
private Transaction GetTransactionForContractZeroInitialization(ContractZeroInitializationInput contractZeroInitializationInput)
{
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
return new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ISmartContractZero.Initialize),
Params = contractZeroInitializationInput.ToByteString()
};
} |
<<<<<<<
var result = await filter.ValidateBlockAsync(block, context);
if (result != BlockValidationResult.Success)
Logger.LogWarning($"Result of {filter.GetType().Name}: {result} - {block.BlockHashToHex}");
=======
var result = await filter.ValidateBlockAsync(block);
if(result != BlockValidationResult.Success)
_logger?.Warn($"Result of {filter.GetType().Name}: {result} - {block.BlockHashToHex}");
>>>>>>>
var result = await filter.ValidateBlockAsync(block);
if (result != BlockValidationResult.Success)
Logger.LogWarning($"Result of {filter.GetType().Name}: {result} - {block.BlockHashToHex}"); |
<<<<<<<
cancellableReturnSets =
await _executingService.ExecuteAsync(blockHeader, cancellable, cancellationToken, false,
returnSetCollection.ToBlockStateSet());
returnSetCollection.AddRange(cancellableReturnSets);
=======
cancellableReturnSets = await _executingService.ExecuteAsync(
new TransactionExecutingDto {BlockHeader = blockHeader, Transactions = cancellable},
cancellationToken, false, returnSetContainer.ToBlockStateSet());
returnSetContainer.AddRange(cancellableReturnSets);
>>>>>>>
cancellableReturnSets = await _executingService.ExecuteAsync(
new TransactionExecutingDto {BlockHeader = blockHeader, Transactions = cancellable},
cancellationToken, false, returnSetCollection.ToBlockStateSet());
returnSetCollection.AddRange(cancellableReturnSets); |
<<<<<<<
=======
public async Task InitialConsensus_WithException()
{
TesterManager.InitialTesters();
//Incorrect round number at beginning.
var input = new Round
{
RoundNumber = 2
};
var transactionResult = await TesterManager.SingleTester.ExecuteConsensusContractMethodWithMiningAsync(
nameof(ConsensusContract.InitialConsensus), input);
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Incorrect round information: invalid round number.").ShouldBeTrue();
//Correct round number
input = new Round
{
RoundNumber = 1
};
transactionResult = await TesterManager.SingleTester.ExecuteConsensusContractMethodWithMiningAsync(
nameof(ConsensusContract.InitialConsensus), input);
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Incorrect round information: no miner.").ShouldBeTrue();
}
[Fact]
public async Task InitialConsensus_Success()
{
TesterManager.InitialTesters();
// Act
var input = TesterManager.MinersKeyPairs.Select(p => p.PublicKey.ToHex()).ToList().ToMiners()
.GenerateFirstRoundOfNewTerm(DPoSSideChainTester.MiningInterval);
var transactionResult = await TesterManager.Testers[0].ExecuteConsensusContractMethodWithMiningAsync(
nameof(ConsensusContract.InitialConsensus), input);
transactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
}
[Fact]
>>>>>>>
<<<<<<<
=======
var triggerInformationForInitialTerm =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(triggerInformationForInitialTerm,
TesterManager.Testers[1]);
>>>>>>>
<<<<<<<
=======
var stubInitialExtraInformation =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(stubInitialExtraInformation, TesterManager.Testers[1]);
>>>>>>>
<<<<<<<
=======
var stubInitialExtraInformation =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(stubInitialExtraInformation, TesterManager.Testers[1]);
>>>>>>>
<<<<<<<
=======
var triggerInformationForInitialTerm =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(triggerInformationForInitialTerm,
TesterManager.Testers[1]);
>>>>>>>
<<<<<<<
=======
var triggerInformationForInitialTerm =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(triggerInformationForInitialTerm,
TesterManager.Testers[1]);
>>>>>>>
<<<<<<<
=======
var triggerInformationForInitialTerm =
TesterManager.GetTriggerInformationForInitialTerm(TesterManager.MinersKeyPairs);
await TesterManager.Testers[0]
.GenerateConsensusTransactionsAndMineABlockAsync(triggerInformationForInitialTerm,
TesterManager.Testers[1]);
>>>>>>> |
<<<<<<<
//local calling graph in template map of template must be topological, so ignore the callGraph
Template.TryGetLocalCallingGraph(classTemplate, out var callGraph, out var topologicRes);
foreach (var localFuncName in topologicRes.Reverse())
{
var funcNameWithAddr =
Replacement.ReplaceValueIntoReplacement(localFuncName, Replacement.This, contractAddr.Value.ToBase64());
var funcMetadata = GetMetadataForNewFunction(funcNameWithAddr, classTemplate[localFuncName], contractAddr, contractReferences, tempMap);
=======
var funcNameWithAddr =
Replacement.ReplaceValueIntoReplacement(localFuncName, Replacement.This, contractAddr.Value.ToByteArray().ToHex());
var funcMetadata = GetMetadataForNewFunction(funcNameWithAddr, classTemplate[localFuncName], contractAddr, contractReferences, tempMap);
>>>>>>>
//local calling graph in template map of template must be topological, so ignore the callGraph
Template.TryGetLocalCallingGraph(classTemplate, out var callGraph, out var topologicRes);
foreach (var localFuncName in topologicRes.Reverse())
{
var funcNameWithAddr =
Replacement.ReplaceValueIntoReplacement(localFuncName, Replacement.This, contractAddr.Value.ToByteArray().ToHex());
var funcMetadata = GetMetadataForNewFunction(funcNameWithAddr, classTemplate[localFuncName], contractAddr, contractReferences, tempMap); |
<<<<<<<
using AElf.OS.Network.Grpc.Extensions;
using AElf.OS.Network.Grpc.Helpers;
=======
using AElf.OS.Network.Protocol;
using AElf.OS.Network.Protocol.Types;
>>>>>>>
using AElf.OS.Network.Grpc.Extensions;
using AElf.OS.Network.Grpc.Helpers;
using AElf.OS.Network.Protocol;
using AElf.OS.Network.Protocol.Types;
<<<<<<<
var metadata = new Metadata {
{GrpcConstants.TimeoutMetadataKey, (NetworkOptions.PeerDialTimeoutInMilliSeconds*2).ToString()} };
connectReply = await client.Client.ConnectAsync(new ConnectRequest { Info = connectionInfo }, metadata);
=======
var metadata = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, (NetworkOptions.PeerDialTimeoutInMilliSeconds * 2).ToString()}
};
handshakeReply =
await client.Client.DoHandshakeAsync(new HandshakeRequest {Handshake = handshake}, metadata);
>>>>>>>
var metadata = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, (NetworkOptions.PeerDialTimeoutInMilliSeconds * 2).ToString()}
};
handshakeReply =
await client.Client.DoHandshakeAsync(new HandshakeRequest {Handshake = handshake}, metadata);
<<<<<<<
public async Task<GrpcPeer> DialBackPeer(IPEndPoint endpoint, ConnectionInfo peerConnectionInfo)
=======
public async Task<GrpcPeer> DialBackPeerAsync(IPEndPoint endpoint, Handshake handshake)
>>>>>>>
public async Task<GrpcPeer> DialBackPeerAsync(IPEndPoint endpoint, Handshake handshake) |
<<<<<<<
private const int BlockRequestTimeout = 300;
private const int BlocksRequestTimeout = 500;
=======
private const int BlockRequestTimeout = 500;
private const int BlocksRequestTimeout = 800;
>>>>>>>
private const int BlockRequestTimeout = 500;
private const int BlocksRequestTimeout = 800;
<<<<<<<
=======
private const int StreamRecoveryWaitTimeInMilliseconds = 500;
private const int MaxDegreeOfParallelismForAnnouncementJobs = 3;
private const int MaxDegreeOfParallelismForTransactionJobs = 1;
private const int MaxDegreeOfParallelismForBlockJobs = 1;
>>>>>>>
private const int StreamRecoveryWaitTimeInMilliseconds = 500;
private const int MaxDegreeOfParallelismForAnnouncementJobs = 3;
private const int MaxDegreeOfParallelismForTransactionJobs = 1;
private const int MaxDegreeOfParallelismForBlockJobs = 1;
<<<<<<<
public bool IsInvalid
{
get
{
return !IsConnected &&
Info.ConnectionTime.AddMilliseconds(NetworkConstants.PeerConnectionTimeout) <
TimestampHelper.GetUtcNow();
}
}
=======
>>>>>>>
public bool IsInvalid
{
get
{
return !IsConnected &&
Info.ConnectionTime.AddMilliseconds(NetworkConstants.PeerConnectionTimeout) <
TimestampHelper.GetUtcNow();
}
}
<<<<<<<
=======
public Handshake LastReceivedHandshake { get; private set; }
>>>>>>>
<<<<<<<
=======
>>>>>>>
<<<<<<<
public async Task SendBlockAsync(BlockWithTransactions blockWithTransactions)
=======
public void EnqueueTransaction(Transaction transaction, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping transaction, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendTransactionJobs.Post(new StreamJob{Transaction = transaction, SendCallback = sendCallback});
}
public void EnqueueAnnouncement(BlockAnnouncement announcement, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping announcement, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendAnnouncementJobs.Post(new StreamJob {BlockAnnouncement = announcement, SendCallback = sendCallback});
}
public void EnqueueBlock(BlockWithTransactions blockWithTransactions, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping block, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendBlockJobs.Post(new StreamJob{BlockWithTransactions = blockWithTransactions, SendCallback = sendCallback});
}
private async Task SendStreamJobAsync(StreamJob job)
>>>>>>>
public void EnqueueTransaction(Transaction transaction, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping transaction, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendTransactionJobs.Post(new StreamJob{Transaction = transaction, SendCallback = sendCallback});
}
public void EnqueueAnnouncement(BlockAnnouncement announcement, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping announcement, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendAnnouncementJobs.Post(new StreamJob {BlockAnnouncement = announcement, SendCallback = sendCallback});
}
public void EnqueueBlock(BlockWithTransactions blockWithTransactions, Action<NetworkException> sendCallback)
{
if (!IsReady)
throw new NetworkException($"Dropping block, peer is not ready - {this}.",
NetworkExceptionType.NotConnected);
_sendBlockJobs.Post(new StreamJob{BlockWithTransactions = blockWithTransactions, SendCallback = sendCallback});
}
private async Task SendStreamJobAsync(StreamJob job)
<<<<<<<
=======
}
job.SendCallback?.Invoke(null);
}
private async Task BroadcastBlockAsync(BlockWithTransactions blockWithTransactions)
{
>>>>>>>
}
job.SendCallback?.Invoke(null);
}
private async Task BroadcastBlockAsync(BlockWithTransactions blockWithTransactions)
{
<<<<<<<
HandleFailure(e, $"Error during block broadcast: {blockWithTransactions.Header.GetHash()}.");
=======
throw;
>>>>>>>
throw;
<<<<<<<
if (!IsConnected)
return;
=======
>>>>>>>
<<<<<<<
if (!IsConnected)
return;
=======
>>>>>>>
<<<<<<<
HandleFailure(e, $"Error during transaction broadcast: {transaction.GetHash()}.");
=======
throw;
>>>>>>>
throw;
<<<<<<<
public async Task ConfirmHandshakeAsync()
{
var request = new GrpcRequest {ErrorMessage = "Error while sending confirm handshake."};
Metadata data = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, UpdateHandshakeTimeout.ToString()}
};
await RequestAsync(_client, c => c.ConfirmHandshakeAsync(new ConfirmHandshakeRequest(), data), request);
}
// todo consider removing client from the lambda as it is not used. It can be capture by the func.
private async Task<TResp> RequestAsync<TResp>(PeerService.PeerServiceClient client,
Func<PeerService.PeerServiceClient, AsyncUnaryCall<TResp>> func, GrpcRequest requestParams)
=======
private async Task<TResp> RequestAsync<TResp>(Func<AsyncUnaryCall<TResp>> func, GrpcRequest requestParams)
>>>>>>>
public async Task ConfirmHandshakeAsync()
{
var request = new GrpcRequest {ErrorMessage = "Error while sending confirm handshake."};
Metadata data = new Metadata
{
{GrpcConstants.TimeoutMetadataKey, UpdateHandshakeTimeout.ToString()}
};
await RequestAsync(() => _client.ConfirmHandshakeAsync(new ConfirmHandshakeRequest(), data), request);
}
private async Task<TResp> RequestAsync<TResp>(Func<AsyncUnaryCall<TResp>> func, GrpcRequest requestParams)
<<<<<<<
if (_channel.State == ChannelState.Shutdown)
{
message = $"Peer is shutdown - {this}: {errorMessage}";
type = NetworkExceptionType.Unrecoverable;
}
else if (_channel.State == ChannelState.TransientFailure || _channel.State == ChannelState.Connecting)
=======
if (_channel.State != ChannelState.Ready)
>>>>>>>
if (_channel.State != ChannelState.Ready)
<<<<<<<
throw new NetworkException(message, exception, type);
=======
return new NetworkException(message, exception, type);
>>>>>>>
return new NetworkException(message, exception, type);
<<<<<<<
=======
// we complete but no need to await the jobs
_sendAnnouncementJobs.Complete();
_sendBlockJobs.Complete();
_sendTransactionJobs.Complete();
_announcementStreamCall?.Dispose();
_transactionStreamCall?.Dispose();
_blockStreamCall?.Dispose();
>>>>>>>
// we complete but no need to await the jobs
_sendAnnouncementJobs.Complete();
_sendBlockJobs.Complete();
_sendTransactionJobs.Complete();
_announcementStreamCall?.Dispose();
_transactionStreamCall?.Dispose();
_blockStreamCall?.Dispose();
<<<<<<<
await RequestAsync(_client,
c => c.DisconnectAsync(new DisconnectReason {Why = DisconnectReason.Types.Reason.Shutdown}),
request);
=======
await RequestAsync(
() => _client.DisconnectAsync(new DisconnectReason
{Why = DisconnectReason.Types.Reason.Shutdown}), request);
>>>>>>>
await RequestAsync(
() => _client.DisconnectAsync(new DisconnectReason
{Why = DisconnectReason.Types.Reason.Shutdown}), request); |
<<<<<<<
using AElf.Standards.ACS2;
using AElf.Contracts.Parliament;
using AElf.Contracts.Profit;
using AElf.Contracts.Referendum;
using AElf.Contracts.TestContract.BasicFunction;
using AElf.Contracts.TestKit;
=======
>>>>>>>
using AElf.Standards.ACS2;
using AElf.Contracts.Parliament;
using AElf.Contracts.Profit;
using AElf.Contracts.Referendum;
<<<<<<<
var category = KernelConstants.CodeCoverageRunnerCategory;
// TokenContract
{
var code = TokenContractCode;
TokenContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
TokenSmartContractAddressNameProvider.Name, DefaultKeyPair));
TokenContractStub =
GetTester<TokenContractImplContainer.TokenContractImplStub>(TokenContractAddress, DefaultKeyPair);
Acs2BaseStub = GetTester<ACS2BaseContainer.ACS2BaseStub>(TokenContractAddress, DefaultKeyPair);
}
// ProfitContract
{
var code = ProfitContractCode;
ProfitContractAddress = AsyncHelper.RunSync(() =>
DeploySystemSmartContract(category, code, ProfitSmartContractAddressNameProvider.Name,
DefaultKeyPair)
);
ProfitContractStub =
GetTester<ProfitContractImplContainer.ProfitContractImplStub>(ProfitContractAddress,
DefaultKeyPair);
}
// TreasuryContract
{
var code = TreasuryContractCode;
TreasuryContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
TreasurySmartContractAddressNameProvider.Name, DefaultKeyPair));
TreasuryContractStub =
GetTester<TreasuryContractImplContainer.TreasuryContractImplStub>(TreasuryContractAddress,
DefaultKeyPair);
}
//TokenConvertContract
{
var code = TokenConverterContractCode;
TokenConverterContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
TokenConverterSmartContractAddressNameProvider.Name, DefaultKeyPair));
TokenConverterContractStub =
GetTester<TokenConverterContractImplContainer.TokenConverterContractImplStub>(TokenConverterContractAddress,
DefaultKeyPair);
}
//ReferendumContract
{
var code = ReferendumContractCode;
ReferendumContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
ReferendumSmartContractAddressNameProvider.Name, DefaultKeyPair));
ReferendumContractStub =
GetTester<ReferendumContractImplContainer.ReferendumContractImplStub>(ReferendumContractAddress,
DefaultKeyPair);
}
//BasicFunctionContract
{
BasicFunctionContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(
category, BasicFunctionContractCode,
BasicFunctionContractName, DefaultKeyPair));
BasicFunctionContractStub =
GetTester<BasicFunctionContractContainer.BasicFunctionContractStub>(BasicFunctionContractAddress,
DefaultKeyPair);
OtherBasicFunctionContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(
category, OtherBasicFunctionContractCode,
OtherBasicFunctionContractName, DefaultKeyPair));
OtherBasicFunctionContractStub =
GetTester<BasicFunctionContractContainer.BasicFunctionContractStub>(
OtherBasicFunctionContractAddress,
DefaultKeyPair);
}
=======
>>>>>>>
<<<<<<<
//ParliamentContract
{
var code = ParliamentCode;
ParliamentContractAddress = AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
ParliamentSmartContractAddressNameProvider.Name, DefaultKeyPair));
ParliamentContractStub =
GetTester<ParliamentContractImplContainer.ParliamentContractImplStub>(ParliamentContractAddress,
DefaultKeyPair);
AsyncHelper.RunSync(InitializeParliamentContract);
}
//AEDPOSContract
{
ConsensusContractAddress = AsyncHelper.RunSync(() =>
DeploySystemSmartContract(
KernelConstants.CodeCoverageRunnerCategory,
ConsensusContractCode,
HashHelper.ComputeFrom("AElf.ContractNames.Consensus"),
DefaultKeyPair
));
AEDPoSContractStub = GetConsensusContractTester(DefaultKeyPair);
AsyncHelper.RunSync(async () => await InitializeAElfConsensus());
}
//AssociationContract
{
var code = AssociationContractCode;
AsyncHelper.RunSync(() => DeploySystemSmartContract(category, code,
AssociationSmartContractAddressNameProvider.Name, DefaultKeyPair));
}
=======
>>>>>>> |
<<<<<<<
public MappedState<string, TokenAmounts> TransactionFees { get; set; }
public SingletonState<Round> RoundBeforeLatestExecution { get; set; }
=======
public MappedState<string, MethodFees> TransactionFees { get; set; }
>>>>>>>
public MappedState<string, MethodFees> TransactionFees { get; set; }
public SingletonState<Round> RoundBeforeLatestExecution { get; set; } |
<<<<<<<
using AElf.OS.Network.Protocol;
using AElf.Types;
=======
using AElf.OS.Network.Infrastructure;
>>>>>>>
using AElf.OS.Network.Protocol;
using AElf.Types;
using AElf.OS.Network.Infrastructure; |
<<<<<<<
_router.Tell(new JobExecutionRequest(reqId, req.ChainId, req.Transactions, Self, _router,
req.DisambiguationHash, req.TransactionType, req.SkipFee));
=======
_router.Tell(new JobExecutionRequest(reqId, req.ChainId, req.Transactions, req.CurrentBlockTime, Self, _router, req.DisambiguationHash));
>>>>>>>
_router.Tell(new JobExecutionRequest(reqId, req.ChainId, req.Transactions, Self, _router, req.CurrentBlockTime,
req.DisambiguationHash, req.TransactionType, req.SkipFee)); |
<<<<<<<
var consensusAddress = ContractHelpers.GetConsensusContractAddress(ChainId);
Logger.LogDebug($"DPoS contract address = {consensusAddress.GetFormatted()}");
=======
var consensusContractAddress = ContractHelpers.GetConsensusContractAddress(ChainId);
_logger?.Debug($"Consensus contract address = {consensusContractAddress.GetFormatted()}");
>>>>>>>
var consensusContractAddress = ContractHelpers.GetConsensusContractAddress(ChainId);
Logger.LogDebug($"Consensus contract address = {consensusContractAddress.GetFormatted()}");
<<<<<<<
Logger.LogDebug($"Resource contract address = {resourceContractAddress.GetFormatted()}");
=======
_logger?.Debug($"Resource contract address = {resourceContractAddress.GetFormatted()}");
var dividendsContractAddress = ContractHelpers.GetDividendsContractAddress(ChainId);
_logger?.Debug($"Dividends contract address = {dividendsContractAddress.GetFormatted()}");
>>>>>>>
Logger.LogDebug($"Resource contract address = {resourceContractAddress.GetFormatted()}");
var dividendsContractAddress = ContractHelpers.GetDividendsContractAddress(ChainId);
Logger.LogDebug($"Dividends contract address = {dividendsContractAddress.GetFormatted()}");
<<<<<<<
{basicReg, tokenCReg, consensusCReg, crossChainCReg, authorizationCReg, resourceCReg}).Result;
Logger.LogDebug($"Genesis block hash = {res.GenesisBlockHash.ToHex()}");
=======
{basicReg, tokenCReg, consensusCReg, crossChainCReg, authorizationCReg, resourceCReg, dividendsCReg}).Result;
_logger?.Debug($"Genesis block hash = {res.GenesisBlockHash.ToHex()}");
>>>>>>>
{basicReg, tokenCReg, consensusCReg, crossChainCReg, authorizationCReg, resourceCReg, dividendsCReg}).Result;
Logger.LogDebug($"Genesis block hash = {res.GenesisBlockHash.ToHex()}"); |
<<<<<<<
using AElf.SmartContract.Proposal;
=======
using AElf.Synchronization.BlockSynchronization;
>>>>>>>
using AElf.SmartContract.Proposal;
using AElf.Synchronization.BlockSynchronization;
<<<<<<<
response["block_number"] = txResult.BlockNumber;
response["block_hash"] = txResult.BlockHash.DumpHex();
try
{
response["return"] = Address.FromBytes(txResult.RetVal.ToByteArray()).GetFormatted();
}
catch (Exception e)
{
// not an error
response["return"] = txResult.RetVal.ToByteArray().ToHex();
}
=======
num = Math.Min(num, block.Body.Transactions.Count - offset);
var txHashs = block.Body.Transactions.ToList().GetRange(offset, num);
foreach (var hash in txHashs)
{
txs.Add(await GetTx(hash));
}
>>>>>>>
num = Math.Min(num, block.Body.Transactions.Count - offset);
var txHashs = block.Body.Transactions.ToList().GetRange(offset, num);
foreach (var hash in txHashs)
{
txs.Add(await GetTx(hash));
} |
<<<<<<<
public MockSetup(IStateStore stateStore, IChainCreationService chainCreationService,
IDataStore dataStore, IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerContainer smartContractRunnerContainer,
IChainService chainService)
=======
public MockSetup(IStateManager stateManager, IChainCreationService chainCreationService,
IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerContainer smartContractRunnerContainer
, ISmartContractManager smartContractManager)
>>>>>>>
public MockSetup(IStateManager stateManager, IChainCreationService chainCreationService,
IChainContextService chainContextService,
IFunctionMetadataService functionMetadataService, ISmartContractRunnerContainer smartContractRunnerContainer,
ISmartContractManager smartContractManager, IChainService chainService)
<<<<<<<
stateStore, _functionMetadataService, chainService);
=======
StateManager, _functionMetadataService);
>>>>>>>
StateManager, _functionMetadataService, chainService); |
<<<<<<<
using AElf.Kernel.SmartContract;
=======
using AElf.Kernel.Consensus.AEDPoS;
using AElf.Kernel.Consensus.AEDPoS.Application;
using AElf.Kernel.Consensus.Application;
>>>>>>>
using AElf.Kernel.SmartContract;
using AElf.Kernel.Consensus.AEDPoS.Application;
using AElf.Kernel.Consensus.Application;
<<<<<<<
context.Services.AddSingleton<ITransactionExecutor, AElfConsensusTransactionExecutor>();
Configure<ContractOptions>(o => o.ContractDeploymentAuthorityRequired = false);
=======
context.Services.AddSingleton<ITransactionExecutor, AEDPoSContractTransactionExecutor>();
context.Services.AddSingleton<ITriggerInformationProvider, AEDPoSTriggerInformationProvider>();
context.Services.AddSingleton<IRandomHashCacheService, MockRandomHashCacheService>();
>>>>>>>
context.Services.AddSingleton<ITransactionExecutor, AEDPoSContractTransactionExecutor>();
context.Services.AddSingleton<ITriggerInformationProvider, AEDPoSTriggerInformationProvider>();
context.Services.AddSingleton<IRandomHashCacheService, MockRandomHashCacheService>();
Configure<ContractOptions>(o => o.ContractDeploymentAuthorityRequired = false); |
<<<<<<<
private TokenContractContainer.TokenContractStub _tokenContractStub;
private Address _testContractAddress;
private TestContract.ContractContainer.ContractStub _testContractStub;
private ECKeyPair DefaultSenderKeyPair => SampleECKeyPairs.KeyPairs[0];
=======
private TokenContractContainer.TokenContractStub TokenContractStub { get; set; }
private Address TestContractAddress { get; set; }
private Address TokenContractAddress { get; set; }
private TestContract.ContractContainer.ContractStub TestContractStub { get; set; }
private ECKeyPair DefaultSenderKeyPair => Accounts[0].KeyPair;
>>>>>>>
private TokenContractContainer.TokenContractStub _tokenContractStub;
private Address _testContractAddress;
private TestContract.ContractContainer.ContractStub _testContractStub;
private ECKeyPair DefaultSenderKeyPair => Accounts[0].KeyPair; |
<<<<<<<
using AElf.Contracts.MultiToken;
=======
using AElf.Contracts.Genesis;
using AElf.Contracts.MultiToken.Messages;
using AElf.Contracts.TestBase;
>>>>>>>
using AElf.Contracts.MultiToken;
using AElf.Contracts.TestBase; |
<<<<<<<
ISmartContractExecutiveService smartContractExecutiveService,
ITransactionInclusivenessProvider transactionInclusivenessProvider,
ITransactionBlockIndexService transactionBlockIndexService)
=======
ITransactionBlockIndexService transactionBlockIndexService,
IForkCacheService forkCacheService,
IChainBlockLinkService chainBlockLinkService)
>>>>>>>
ISmartContractExecutiveService smartContractExecutiveService,
ITransactionBlockIndexService transactionBlockIndexService,
IForkCacheService forkCacheService,
IChainBlockLinkService chainBlockLinkService)
<<<<<<<
await _transactionBlockIndexService.CleanTransactionBlockIndexCacheAsync(eventData.BlockHeight);
// Clean up long unused executive
_smartContractExecutiveService.ClearExecutive();
=======
await _transactionBlockIndexService.CleanTransactionBlockIndexCacheAsync(irreversibleBlockHeight);
>>>>>>>
await _transactionBlockIndexService.CleanTransactionBlockIndexCacheAsync(irreversibleBlockHeight);
// Clean up long unused executive
_smartContractExecutiveService.ClearExecutive(); |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.