conflict_resolution
stringlengths 27
16k
|
|---|
<<<<<<<
=======
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
>>>>>>>
using Google.Protobuf;
<<<<<<<
return _fakeIndexedCrossChainBlockData.TryGetValue(height, out var crossChainBlockData)
? crossChainBlockData
: null;
}
=======
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetParentChainId))
{
var parentChainId = _parentChainIdHeight.Keys.FirstOrDefault();
if (parentChainId != 0)
return new Int32Value {Value = parentChainId}.ToByteArray();
trace.ExecutionStatus = ExecutionStatus.ContractError;
return null;
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetParentChainHeight))
{
return _parentChainIdHeight.Count == 0
? null
: new Int64Value {Value = _parentChainIdHeight.Values.First()}.ToByteArray();
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetSideChainHeight))
{
int sideChainId = Int32Value.Parser.ParseFrom(transaction.Params).Value;
var exist = _sideChainIdHeights.TryGetValue(sideChainId, out var sideChainHeight);
if (exist)
return new Int64Value{Value = sideChainHeight}.ToByteArray();
trace.ExecutionStatus = ExecutionStatus.ContractError;
return new Int64Value().ToByteArray();
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetAllChainsIdAndHeight))
{
var dict = new SideChainIdAndHeightDict();
dict.IdHeightDict.Add(_sideChainIdHeights);
dict.IdHeightDict.Add(_parentChainIdHeight);
return dict.ToByteArray();
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetSideChainIdAndHeight))
{
var dict = new SideChainIdAndHeightDict();
dict.IdHeightDict.Add(_sideChainIdHeights);
return dict.ToByteArray();
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetIndexedCrossChainBlockDataByHeight))
{
long height = Int64Value.Parser.ParseFrom(transaction.Params).Value;
if (_indexedCrossChainBlockData.TryGetValue(height, out var crossChainBlockData))
return crossChainBlockData.ToByteArray();
trace.ExecutionStatus = ExecutionStatus.ContractError;
return new CrossChainBlockData().ToByteArray();
}
if (methodName == nameof(CrossChainContractContainer.CrossChainContractStub.GetSideChainIndexingInformationList))
{
var sideChainIndexingInformationList = new SideChainIndexingInformationList();
foreach (var kv in _sideChainIdHeights)
{
sideChainIndexingInformationList.IndexingInformationList.Add(new SideChainIndexingInformation
{
ChainId = kv.Key,
IndexedHeight = kv.Value
});
}
return sideChainIndexingInformationList.ToByteArray();
}
>>>>>>>
return _fakeIndexedCrossChainBlockData.TryGetValue(height, out var crossChainBlockData)
? crossChainBlockData
: null;
} |
<<<<<<<
Hash Hash { get;}
=======
Int32 Version { get; set; }
Hash MerkleTreeRootOfTransactions { get; set; }
>>>>>>>
Hash Hash { get;}
Int32 Version { get; set; }
Hash MerkleTreeRootOfTransactions { get; set; } |
<<<<<<<
using AElf.Common.Extensions;
=======
using AElf.ChainController.TxMemPool;
>>>>>>>
using AElf.Common.Extensions;
using AElf.ChainController.TxMemPool; |
<<<<<<<
=======
private static ulong _firstTermChangedRoundNumber;
>>>>>>>
private static ulong _firstTermChangedRoundNumber;
<<<<<<<
=======
if (ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId)
{
await _minersManager.SetMiners(miners);
}
>>>>>>>
if (ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId)
{
await _minersManager.SetMiners(miners);
}
<<<<<<<
_helper.TryToGetVictories(out var victories);
_logger?.Trace("Miners of next term:");
foreach (var victory in victories)
{
_logger?.Trace(victory);
}
var parameters = new List<object>
=======
Term nextTerm;
if (_helper.TryToGetVictories(out var victories))
{
nextTerm = victories.ToMiners().GenerateNewTerm(ConsensusConfig.Instance.DPoSMiningInterval,
_helper.CurrentRoundNumber.Value, _helper.CurrentTermNumber.Value);
}
else
{
nextTerm = (await _minersManager.GetMiners()).GenerateNewTerm(
ConsensusConfig.Instance.DPoSMiningInterval, _helper.CurrentRoundNumber.Value,
_helper.CurrentTermNumber.Value);
}
var txs = new List<Transaction>
>>>>>>>
Term nextTerm;
if (_helper.TryToGetVictories(out var victories))
{
nextTerm = victories.ToMiners().GenerateNewTerm(ConsensusConfig.Instance.DPoSMiningInterval,
_helper.CurrentRoundNumber.Value, _helper.CurrentTermNumber.Value);
}
else
{
nextTerm = (await _minersManager.GetMiners()).GenerateNewTerm(
ConsensusConfig.Instance.DPoSMiningInterval, _helper.CurrentRoundNumber.Value,
_helper.CurrentTermNumber.Value);
}
var txs = new List<Transaction>
<<<<<<<
// if (_helper.TryGetRoundInfo(LatestRoundNumber, out var previousRoundInfo))
// {
// var currentRoundInfo = _helper.GetCurrentRoundInfo();
// if (currentRoundInfo.MinersHash() != previousRoundInfo.MinersHash())
// {
// _logger?.Trace("Updating miners.");
// await _minersManager.SetMiners(_helper.GetCurrentMiners());
// }
// }
=======
if (ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId &&
_helper.TryGetRoundInfo(LatestRoundNumber, out var previousRoundInfo))
{
var currentRoundInfo = _helper.GetCurrentRoundInfo();
if (currentRoundInfo.MinersHash() != previousRoundInfo.MinersHash())
{
_logger?.Trace("Updating miners.");
await _minersManager.SetMiners(_helper.GetCurrentMiners());
}
}
>>>>>>>
// if (ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId &&
// _helper.TryGetRoundInfo(LatestRoundNumber, out var previousRoundInfo))
// {
// var currentRoundInfo = _helper.GetCurrentRoundInfo();
// if (currentRoundInfo.MinersHash() != previousRoundInfo.MinersHash())
// {
// _logger?.Trace("Updating miners.");
// await _minersManager.SetMiners(_helper.GetCurrentMiners());
// }
// } |
<<<<<<<
=======
/// <summary>
/// First step of the connect/auth process. Used to initiate a connection. The provided payload should be the
/// clients authentication information. When receiving this call, protocol dictates you send the client your auth
/// information. The response says whether or not you can connect.
/// </summary>
public override async Task<ConnectReply> Connect(ConnectRequest connectionRequest, ServerCallContext context)
{
Logger.LogTrace($"{context.Peer} has initiated a connection.");
if(!UriHelper.TryParsePrefixedEndpoint(context.Peer, out IPEndPoint peerEndpoint))
return new ConnectReply { Error = ConnectError.InvalidPeer };
return await _connectionService.DialBackAsync(peerEndpoint, connectionRequest.Info);
}
>>>>>>> |
<<<<<<<
using AElf.Kernel.SmartContractExecution.Application;
=======
using AElf.Kernel.SmartContract.Application;
using AElf.Kernel.SmartContractExecution.Application;
>>>>>>>
using AElf.Kernel.SmartContractExecution.Application;
using AElf.Kernel.SmartContract.Application;
using AElf.Kernel.SmartContractExecution.Application;
<<<<<<<
_transactionReadOnlyExecutionService = transactionReadOnlyExecutionService;
=======
_smartContractAddressService = smartContractAddressService;
>>>>>>>
_transactionReadOnlyExecutionService = transactionReadOnlyExecutionService;
_smartContractAddressService = smartContractAddressService; |
<<<<<<<
private static Address CrossChainContractAddress => ContractHelpers.GetCrossChainContractAddress(ChainId);
private static Address AuthorizationContractAddress => ContractHelpers.GetAuthorizationContractAddress(ChainId);
private static Address ResourceContractAddress => ContractHelpers.GetResourceContractAddress(ChainId);
private static Address TokenContractAddress => ContractHelpers.GetTokenContractAddress(ChainId);
private static Address ConsensusContractAddress => ContractHelpers.GetConsensusContractAddress(ChainId);
public static Address Genesis => Address.Genesis;
=======
public static Address GetSideChainContractAddress()
{
return ContractHelpers.GetSideChainContractAddress(_smartContractContext.ChainId);
}
public static Address GetAuthorizationContractAddress()
{
return ContractHelpers.GetAuthorizationContractAddress(_smartContractContext.ChainId);
}
>>>>>>>
private static Address CrossChainContractAddress => ContractHelpers.GetCrossChainContractAddress(ChainId);
private static Address AuthorizationContractAddress => ContractHelpers.GetAuthorizationContractAddress(ChainId);
private static Address ResourceContractAddress => ContractHelpers.GetResourceContractAddress(ChainId);
private static Address TokenContractAddress => ContractHelpers.GetTokenContractAddress(ChainId);
private static Address ConsensusContractAddress => ContractHelpers.GetConsensusContractAddress(ChainId);
public static Address Genesis => Address.Genesis;
<<<<<<<
/// <summary>
/// Recover the first public key signing this transaction.
/// </summary>
/// <returns></returns>
public static byte[] RecoverPublicKey()
{
return RecoverPublicKey(GetTransaction().Sigs.First().ToByteArray(), GetTxnHash().DumpByteArray());
}
public static List<byte[]> GetSystemReviewers()
=======
public static List<Reviewer> GetSystemReviewers()
>>>>>>>
/// <summary>
/// Recover the first public key signing this transaction.
/// </summary>
/// <returns></returns>
public static byte[] RecoverPublicKey()
{
return RecoverPublicKey(GetTransaction().Sigs.First().ToByteArray(), GetTxnHash().DumpByteArray());
}
public static List<byte[]> GetSystemReviewers()
<<<<<<<
public static bool VerifyTransaction(Hash txId, MerklePath merklePath, ulong parentChainHeight)
{
var scAddress = CrossChainContractAddress;
if (scAddress == null)
{
throw new InternalError("No side chain contract was found.\n" + _lastCallContext.Trace.StdErr);
}
if (Call(scAddress, "VerifyTransaction", ParamsPacker.Pack(txId, merklePath, parentChainHeight)))
{
return GetCallResult().DeserializeToPbMessage<BoolValue>().Value;
}
return false;
}
public static void LockToken(ulong amount)
{
SendInline(TokenContractAddress, "Transfer", GetContractAddress(), amount);
}
public static void WithdrawToken(Address address, ulong amount)
{
SendInlineByContract(TokenContractAddress, "Transfer", address, amount);
}
public static void LockResource(ulong amount, ResourceType resourceType)
{
SendInline(ResourceContractAddress, "LockResource", GetContractAddress(), amount, resourceType);
}
public static void WithdrawResource(ulong amount, ResourceType resourceType)
{
SendInlineByContract(ResourceContractAddress, "WithdrawResource", GetFromAddress(), amount, resourceType);
}
=======
>>>>>>>
public static bool VerifyTransaction(Hash txId, MerklePath merklePath, ulong parentChainHeight)
{
var scAddress = CrossChainContractAddress;
if (scAddress == null)
{
throw new InternalError("No side chain contract was found.\n" + _lastCallContext.Trace.StdErr);
}
if (Call(scAddress, "VerifyTransaction", ParamsPacker.Pack(txId, merklePath, parentChainHeight)))
{
return GetCallResult().DeserializeToPbMessage<BoolValue>().Value;
}
return false;
}
public static void LockToken(ulong amount)
{
SendInline(TokenContractAddress, "Transfer", GetContractAddress(), amount);
}
public static void WithdrawToken(Address address, ulong amount)
{
SendInlineByContract(TokenContractAddress, "Transfer", address, amount);
}
public static void LockResource(ulong amount, ResourceType resourceType)
{
SendInline(ResourceContractAddress, "LockResource", GetContractAddress(), amount, resourceType);
}
public static void WithdrawResource(ulong amount, ResourceType resourceType)
{
SendInlineByContract(ResourceContractAddress, "WithdrawResource", GetFromAddress(), amount, resourceType);
}
<<<<<<<
return;
Call(AuthorizationContractAddress, "GetAuth", ParamsPacker.Pack(_transactionContext.Transaction.From));
=======
return true;
Call(GetAuthorizationContractAddress(), "GetAuth", ParamsPacker.Pack(_transactionContext.Transaction.From));
>>>>>>>
return;
Call(AuthorizationContractAddress, "GetAuth", ParamsPacker.Pack(_transactionContext.Transaction.From));
<<<<<<<
=======
>>>>>>> |
<<<<<<<
using AElf.Kernel.Account.Application;
using AElf.Kernel.Infrastructure;
using AElf.Miner.Rpc;
=======
using AElf.Kernel.Storages;
>>>>>>>
using AElf.Kernel.Account.Application;
using AElf.Kernel.Infrastructure; |
<<<<<<<
=======
private readonly ECKeyPair _keyPair = NodeConfig.Instance.ECKeyPair;
>>>>>>>
<<<<<<<
=======
private readonly int _timeoutMilliseconds = ConsensusConfig.Instance.DPoSMiningInterval / 4 * 3;
private readonly ILogger _logger;
private readonly ClientManager _clientManager;
>>>>>>>
<<<<<<<
=======
/// <summary>
/// Stop mining
/// </summary>
public void Close()
{
_clientManager.CloseClientsToSideChain();
_serverManager.Close();
}
>>>>>>> |
<<<<<<<
public ulong GetSideChainHeight(int chainId)
=======
public long GetSideChainHeight(string chainId)
>>>>>>>
public long GetSideChainHeight(int chainId)
<<<<<<<
Assert(parentChainId == blockInfo.Root.ParentChainId, "Wrong parent chain id.");
ulong parentChainHeight = blockInfo.Root.ParentChainHeight;
=======
long parentChainHeight = blockInfo.Root.ParentChainHeight;
>>>>>>>
Assert(parentChainId == blockInfo.Root.ParentChainId, "Wrong parent chain id.");
long parentChainHeight = blockInfo.Root.ParentChainHeight;
<<<<<<<
=======
//Console.WriteLine("Side chain height: {0}", blockInfo.Height);
var sideChainHeight = blockInfo.SideChainHeight;
>>>>>>>
<<<<<<<
var key = new UInt64Value {Value = parentChainHeight};
var merkleTreeRoot = State.TransactionMerkleTreeRootRecordedInParentChain[parentChainHeight];
Assert(merkleTreeRoot != null,
=======
var key = new Int64Value {Value = parentChainHeight};
var parentChainBlockInfo = State.ParentChainBlockInfo[parentChainHeight];
Assert(parentChainBlockInfo != null,
>>>>>>>
var key = new Int64Value {Value = parentChainHeight};
var merkleTreeRoot = State.TransactionMerkleTreeRootRecordedInParentChain[parentChainHeight];
Assert(merkleTreeRoot != null, |
<<<<<<<
#if WINDOWS_UAP
this.definitions.Add(new ExampleDefinition() { Name = "Video Effect", Control = typeof(BasicVideoEffectExample) });
#endif
=======
this.definitions.Add(new ExampleDefinition() { Name = "Control Transforms", Control = typeof(ControlTransforms) });
>>>>>>>
this.definitions.Add(new ExampleDefinition() { Name = "Control Transforms", Control = typeof(ControlTransforms) });
#if WINDOWS_UAP
this.definitions.Add(new ExampleDefinition() { Name = "Video Effect", Control = typeof(BasicVideoEffectExample) });
#endif |
<<<<<<<
=======
MessageHub.Instance.Publish(new ExecutionStateChanged(true));
var stopwatch = new Stopwatch();
stopwatch.Start();
>>>>>>>
MessageHub.Instance.Publish(new ExecutionStateChanged(true));
var stopwatch = new Stopwatch();
stopwatch.Start();
<<<<<<<
=======
MessageHub.Instance.Publish(new ExecutionStateChanged(false));
>>>>>>>
MessageHub.Instance.Publish(new ExecutionStateChanged(false)); |
<<<<<<<
_txFilter.Execute(sysTxs);
Logger.LogTrace($"Start executing {sysTxs.Count} system transactions.");
=======
var toRemove = _txFilter.Execute(sysTxs);
// TODO: Remove useless consensus txs.
_logger?.Trace($"Start executing {sysTxs.Count} system transactions.");
>>>>>>>
var toRemove = _txFilter.Execute(sysTxs);
// TODO: Remove useless consensus txs.
Logger.LogTrace($"Start executing {sysTxs.Count} system transactions."); |
<<<<<<<
using System.Numerics;
=======
using System.Linq;
>>>>>>>
using System.Linq;
using System.Numerics; |
<<<<<<<
using Volo.Abp.DependencyInjection;
=======
using AElf.Kernel.Managers;
>>>>>>>
using AElf.Kernel.Managers;
using Volo.Abp.DependencyInjection; |
<<<<<<<
RegisterTokenInfo(nativeTokenInfo);
if (input.ResourceTokenList?.Value != null)
{
foreach (var resourceTokenInfo in input.ResourceTokenList.Value)
{
resourceTokenInfo.Supply = 0;
RegisterTokenInfo(resourceTokenInfo);
}
}
=======
RegisterTokenInfo(nativeTokenInfo);
Assert(input.ChainPrimaryToken.IssueChainId == Context.ChainId, "Invalid primary token info.");
State.ChainPrimaryTokenSymbol.Value = input.ChainPrimaryToken.Symbol;
RegisterTokenInfo(input.ChainPrimaryToken);
foreach (var resourceTokenInfo in input.ResourceTokenList.Value)
{
resourceTokenInfo.Supply = 0;
RegisterTokenInfo(resourceTokenInfo);
}
>>>>>>>
RegisterTokenInfo(nativeTokenInfo);
Assert(input.ChainPrimaryToken.IssueChainId == Context.ChainId, "Invalid primary token info.");
State.ChainPrimaryTokenSymbol.Value = input.ChainPrimaryToken.Symbol;
RegisterTokenInfo(input.ChainPrimaryToken);
if (input.ResourceTokenList?.Value != null)
{
foreach (var resourceTokenInfo in input.ResourceTokenList.Value)
{
resourceTokenInfo.Supply = 0;
RegisterTokenInfo(resourceTokenInfo);
}
}
<<<<<<<
var isMainChain = true;
=======
Context.LogDebug(() => "Start executing DonateResourceToken");
var isMainChain = true;
>>>>>>>
var isMainChain = true; |
<<<<<<<
public const int DefaultMinBlockGapBeforeSync = 1024;
=======
public const int DefaultMaxPeers = 25;
>>>>>>>
public const int DefaultMinBlockGapBeforeSync = 1024;
public const int DefaultMaxPeers = 25; |
<<<<<<<
using AElf.SmartContract;
using AElf.Kernel.TransactionPool;
=======
using AElf.TxPool;
>>>>>>>
using AElf.Kernel.TransactionPool;
<<<<<<<
[DependsOn(typeof(RpcAElfModule),typeof(ChainControllerAElfModule),typeof(TransactionPoolAElfModule)
)]
public class RpcChainControllerAElfModule: AElfModule
=======
[DependsOn(typeof(RpcAElfModule), typeof(ChainControllerAElfModule), typeof(TxPoolAElfModule))]
public class RpcChainControllerAElfModule : AElfModule
>>>>>>>
[DependsOn(typeof(RpcAElfModule), typeof(ChainControllerAElfModule), typeof(TransactionPoolAElfModule))]
public class RpcChainControllerAElfModule : AElfModule |
<<<<<<<
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using AElf.Common;
using AElf.Contracts.TestBase;
using AElf.Database;
using AElf.Kernel;
using AElf.Kernel.Account.Application;
using AElf.Kernel.Blockchain.Application;
using AElf.Kernel.Infrastructure;
using AElf.Kernel.SmartContractExecution.Application;
=======
using AElf.Kernel.Tests;
>>>>>>>
using System;
using System.Linq;
using System.Threading.Tasks;
using AElf.Common;
using AElf.Contracts.TestBase;
using AElf.Kernel;
using AElf.Kernel.Account.Application;
using AElf.Kernel.SmartContractExecution.Application;
using AElf.Kernel.Tests;
<<<<<<<
[DependsOn(typeof(AbpEventBusModule),
typeof(ContractTestAElfModule),
typeof(CrossChainAElfModule))]
=======
[DependsOn(
typeof(CrossChainAElfModule),
typeof(KernelTestAElfModule))]
>>>>>>>
[DependsOn(
typeof(ContractTestAElfModule),
typeof(CrossChainAElfModule),
typeof(KernelTestAElfModule))]
<<<<<<<
=======
>>>>>>>
<<<<<<<
var services = context.Services;
services.AddKeyValueDbContext<BlockchainKeyValueDbContext>(o => o.UseInMemoryDatabase());
services.AddKeyValueDbContext<StateKeyValueDbContext>(o => o.UseInMemoryDatabase());
// todo: Remove this
context.Services.AddTransient<ITransactionResultQueryService, NoBranchTransactionResultService>();
context.Services.AddTransient<ITransactionResultService, NoBranchTransactionResultService>();
var keyPair = CrossChainTestHelper.EcKeyPair;
var mockAccountService = new Mock<IAccountService>();
mockAccountService.Setup(m => m.GetPublicKeyAsync()).Returns(Task.FromResult(keyPair.PublicKey));
mockAccountService.Setup(m => m.GetAccountAsync())
.Returns(Task.FromResult(Address.FromPublicKey(keyPair.PublicKey)));
context.Services.AddTransient(provider => mockAccountService.Object);
context.Services.AddSingleton<CrossChainTestHelper>();
// var extraDataOrderInformation = context.Services.GetRequiredServiceLazy<IBlockExtraDataOrderService>().Value;
// var blockExtraDataProviders = context.Services.GetRequiredServiceLazy<IEnumerable<IBlockExtraDataProvider>>().Value;
// foreach (var blockExtraDataProvider in blockExtraDataProviders)
// {
// extraDataOrderInformation.AddExtraDataProvider(blockExtraDataProvider.GetType());
// }
context.Services.AddTransient(provider =>
{
var mockTransactionReadOnlyExecutionService = new Mock<ITransactionReadOnlyExecutionService>();
mockTransactionReadOnlyExecutionService
.Setup(m => m.ExecuteAsync(It.IsAny<IChainContext>(), It.IsAny<Transaction>(), It.IsAny<DateTime>()))
.Returns<IChainContext, Transaction, DateTime>((chainContext, transaction, dateTime) =>
{
var crossChainTestHelper = context.Services.GetRequiredServiceLazy<CrossChainTestHelper>().Value;
string methodName = transaction.MethodName;
var trace = new TransactionTrace
{
TransactionId = transaction.GetHash(),
ExecutionStatus = ExecutionStatus.ExecutedButNotCommitted,
RetVal = new RetVal()
};
if (methodName == CrossChainConsts.GetParentChainIdMethodName)
{
var parentChainId = crossChainTestHelper.ParentChainIdHeight.Keys.FirstOrDefault();
if(parentChainId == 0)
trace.ExecutionStatus = ExecutionStatus.ContractError;
else
trace.RetVal.Data = parentChainId.ToPbMessage().ToByteString();
}
else if (methodName == CrossChainConsts.GetParentChainHeightMethodName)
{
trace.RetVal.Data = crossChainTestHelper.ParentChainIdHeight.Values.First().ToPbMessage()
.ToByteString();
}
else if (methodName == CrossChainConsts.GetSideChainHeightMethodName)
{
int sideChainId =
(int) ParamsPacker.Unpack(transaction.Params.ToByteArray(), new[] {typeof(int)})[0];
var exist = crossChainTestHelper.SideChainIdHeights.TryGetValue(sideChainId, out var sideChainHeight);
if (!exist)
trace.ExecutionStatus = ExecutionStatus.ContractError;
else
trace.RetVal.Data = sideChainHeight.ToPbMessage().ToByteString();
}
else if (methodName == CrossChainConsts.GetAllChainsIdAndHeightMethodName)
{
var dict = new SideChainIdAndHeightDict();
dict.IdHeighDict.Add(crossChainTestHelper.SideChainIdHeights);
dict.IdHeighDict.Add(crossChainTestHelper.ParentChainIdHeight);
trace.RetVal.Data = dict.ToByteString();
}
else if (methodName == CrossChainConsts.GetSideChainIdAndHeightMethodName)
{
var dict = new SideChainIdAndHeightDict();
dict = new SideChainIdAndHeightDict();
dict.IdHeighDict.Add(crossChainTestHelper.SideChainIdHeights);
trace.RetVal.Data = dict.ToByteString();
}
else if(methodName == CrossChainConsts.GetIndexedCrossChainBlockDataByHeight)
{
long height =
(long) ParamsPacker.Unpack(transaction.Params.ToByteArray(), new[] {typeof(long)})[0];
if (!crossChainTestHelper.IndexedCrossChainBlockData.TryGetValue(height,
out var crossChainBlockData))
{
trace.ExecutionStatus = ExecutionStatus.ContractError;
}
else
trace.RetVal.Data = crossChainBlockData.ToByteString();
}
return Task.FromResult(trace);
});
return mockTransactionReadOnlyExecutionService.Object;
});
}
=======
//TODO: please mock data here, do not directly new object, if you have multiple dependency, you should have
//different modules, like AElfIntegratedTest<AAACrossChainTestModule>, AElfIntegratedTest<BBBCrossChainTestModule>
}
>>>>>>>
var keyPair = CrossChainTestHelper.EcKeyPair;
var mockAccountService = new Mock<IAccountService>();
mockAccountService.Setup(m => m.GetPublicKeyAsync()).Returns(Task.FromResult(keyPair.PublicKey));
mockAccountService.Setup(m => m.GetAccountAsync())
.Returns(Task.FromResult(Address.FromPublicKey(keyPair.PublicKey)));
context.Services.AddTransient(provider => mockAccountService.Object);
context.Services.AddSingleton<CrossChainTestHelper>();
// var extraDataOrderInformation = context.Services.GetRequiredServiceLazy<IBlockExtraDataOrderService>().Value;
// var blockExtraDataProviders = context.Services.GetRequiredServiceLazy<IEnumerable<IBlockExtraDataProvider>>().Value;
// foreach (var blockExtraDataProvider in blockExtraDataProviders)
// {
// extraDataOrderInformation.AddExtraDataProvider(blockExtraDataProvider.GetType());
// }
context.Services.AddTransient(provider =>
{
var mockTransactionReadOnlyExecutionService = new Mock<ITransactionReadOnlyExecutionService>();
mockTransactionReadOnlyExecutionService
.Setup(m => m.ExecuteAsync(It.IsAny<IChainContext>(), It.IsAny<Transaction>(), It.IsAny<DateTime>()))
.Returns<IChainContext, Transaction, DateTime>((chainContext, transaction, dateTime) =>
{
var crossChainTestHelper = context.Services.GetRequiredServiceLazy<CrossChainTestHelper>().Value;
string methodName = transaction.MethodName;
var trace = new TransactionTrace
{
TransactionId = transaction.GetHash(),
ExecutionStatus = ExecutionStatus.ExecutedButNotCommitted,
RetVal = new RetVal()
};
if (methodName == CrossChainConsts.GetParentChainIdMethodName)
{
var parentChainId = crossChainTestHelper.ParentChainIdHeight.Keys.FirstOrDefault();
if(parentChainId == 0)
trace.ExecutionStatus = ExecutionStatus.ContractError;
else
trace.RetVal.Data = parentChainId.ToPbMessage().ToByteString();
}
else if (methodName == CrossChainConsts.GetParentChainHeightMethodName)
{
trace.RetVal.Data = crossChainTestHelper.ParentChainIdHeight.Values.First().ToPbMessage()
.ToByteString();
}
else if (methodName == CrossChainConsts.GetSideChainHeightMethodName)
{
int sideChainId =
(int) ParamsPacker.Unpack(transaction.Params.ToByteArray(), new[] {typeof(int)})[0];
var exist = crossChainTestHelper.SideChainIdHeights.TryGetValue(sideChainId, out var sideChainHeight);
if (!exist)
trace.ExecutionStatus = ExecutionStatus.ContractError;
else
trace.RetVal.Data = sideChainHeight.ToPbMessage().ToByteString();
}
else if (methodName == CrossChainConsts.GetAllChainsIdAndHeightMethodName)
{
var dict = new SideChainIdAndHeightDict();
dict.IdHeighDict.Add(crossChainTestHelper.SideChainIdHeights);
dict.IdHeighDict.Add(crossChainTestHelper.ParentChainIdHeight);
trace.RetVal.Data = dict.ToByteString();
}
else if (methodName == CrossChainConsts.GetSideChainIdAndHeightMethodName)
{
var dict = new SideChainIdAndHeightDict();
dict = new SideChainIdAndHeightDict();
dict.IdHeighDict.Add(crossChainTestHelper.SideChainIdHeights);
trace.RetVal.Data = dict.ToByteString();
}
else if(methodName == CrossChainConsts.GetIndexedCrossChainBlockDataByHeight)
{
long height =
(long) ParamsPacker.Unpack(transaction.Params.ToByteArray(), new[] {typeof(long)})[0];
if (!crossChainTestHelper.IndexedCrossChainBlockData.TryGetValue(height,
out var crossChainBlockData))
{
trace.ExecutionStatus = ExecutionStatus.ContractError;
}
else
trace.RetVal.Data = crossChainBlockData.ToByteString();
}
return Task.FromResult(trace);
});
return mockTransactionReadOnlyExecutionService.Object;
});
} |
<<<<<<<
=======
private ActorSystem _sys ;
private readonly IBlockManager _blockManager;
>>>>>>>
private ActorSystem _sys ;
private readonly IBlockManager _blockManager;
<<<<<<<
IChainCreationService chainCreationService, IWorldStateManager worldStateManager,
ISmartContractService contractService)
=======
IChainCreationService chainCreationService, IWorldStateManager worldStateManager,
IChainManager chainManager, ISmartContractService smartContractService, ActorSystem sys, IBlockManager blockManager)
>>>>>>>
IChainCreationService chainCreationService, IWorldStateManager worldStateManager,
IChainManager chainManager, ISmartContractService smartContractService, ActorSystem sys, IBlockManager blockManager)
<<<<<<<
if (_nodeConfig.IsMiner)
_miner.Start(nodeKeyPair);
=======
if (_nodeConfig.IsMiner)
{
// akka env
IActorRef serviceRouter = _sys.ActorOf(LocalServicesProvider.Props(new ServicePack
{
ChainContextService = _chainContextService,
SmartContractService = _smartContractService,
ResourceDetectionService = new MockResourceUsageDetectionService()
}));
IActorRef generalExecutor = _sys.ActorOf(GeneralExecutor.Props(_sys, serviceRouter), "exec");
generalExecutor.Tell(new RequestAddChainExecutor(_nodeConfig.ChainId));
_miner.Start(nodeKeyPair);
/*ECKeyPair keyPair = new KeyPairGenerator().Generate();
ECSigner signer = new ECSigner();
var txPrint = new Transaction
{
From = keyPair.GetAddress(),
To = new Hash(_nodeConfig.ChainId.CalculateHashWith("__SmartContractZero__")).ToAccount(),
IncrementId = 0,
MethodName = "Print",
Params = ByteString.CopyFrom(new Parameters()
{
Params = {
new Param
{
StrVal = "aElf"
}
}
}.ToByteArray()),
Fee = TxPoolConfig.Default.FeeThreshold + 1
};
Hash hash = txPrint.GetHash();
ECSignature signature = signer.Sign(keyPair, hash.GetHashBytes());
txPrint.P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded());
txPrint.R = ByteString.CopyFrom(signature.R);
txPrint.S = ByteString.CopyFrom(signature.S);
>>>>>>>
if (_nodeConfig.IsMiner)
{
// akka env
IActorRef serviceRouter = _sys.ActorOf(LocalServicesProvider.Props(new ServicePack
{
ChainContextService = _chainContextService,
SmartContractService = _smartContractService,
ResourceDetectionService = new MockResourceUsageDetectionService()
}));
IActorRef generalExecutor = _sys.ActorOf(GeneralExecutor.Props(_sys, serviceRouter), "exec");
generalExecutor.Tell(new RequestAddChainExecutor(_nodeConfig.ChainId));
_miner.Start(nodeKeyPair);
/*ECKeyPair keyPair = new KeyPairGenerator().Generate();
ECSigner signer = new ECSigner();
var txPrint = new Transaction
{
From = keyPair.GetAddress(),
To = new Hash(_nodeConfig.ChainId.CalculateHashWith("__SmartContractZero__")).ToAccount(),
IncrementId = 0,
MethodName = "Print",
Params = ByteString.CopyFrom(new Parameters()
{
Params = {
new Param
{
StrVal = "aElf"
}
}
}.ToByteArray()),
Fee = TxPoolConfig.Default.FeeThreshold + 1
};
Hash hash = txPrint.GetHash();
ECSignature signature = signer.Sign(keyPair, hash.GetHashBytes());
txPrint.P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded());
txPrint.R = ByteString.CopyFrom(signature.R);
txPrint.S = ByteString.CopyFrom(signature.S);
<<<<<<<
=======
>>>>>>>
<<<<<<<
// todo : fake block for now
var blockb = new Block(ByteArrayHelpers.RandomFill(10));
blockb.Header.ChainId = ByteArrayHelpers.RandomFill(10);
blockb.Header.Time = Timestamp.FromDateTime(DateTime.UtcNow);
blockb.Header.PreviousBlockHash = ByteArrayHelpers.RandomFill(256);
blockb.AddTransaction(Hash.Generate());
await _protocolDirector.BroadcastBlock(blockb);
=======
await _protocolDirector.BroadcastBlock(block as Block);
>>>>>>>
await _protocolDirector.BroadcastBlock(block as Block); |
<<<<<<<
_dataStore.SetDataAsync(CalculateKeyForPathsCount(), ((long)0).ToBytes());
=======
_dataStore.SetDataAsync(GetHashToGetPathsCount(), ((ulong)0).ToBytes());
>>>>>>>
_dataStore.SetDataAsync(CalculateKeyForPathsCount(), ((ulong)0).ToBytes());
<<<<<<<
var countBytes = await _dataStore.GetDataAsync(CalculateKeyForPathsCount());
countBytes = countBytes ?? ((long)0).ToBytes();
var key = CalculateKeyForPath(_preBlockHash, countBytes);
=======
var countBytes = await _dataStore.GetDataAsync(GetHashToGetPathsCount());
countBytes = countBytes ?? ((ulong)0).ToBytes();
var key = CalculateHashToGetPath(_preBlockHash, countBytes);
>>>>>>>
var countBytes = await _dataStore.GetDataAsync(CalculateKeyForPathsCount());
countBytes = countBytes ?? ((ulong)0).ToBytes();
var key = CalculateKeyForPath(_preBlockHash, countBytes); |
<<<<<<<
var txCtxt = new TransactionContext()
{
PreviousBlockHash = _chainContext.BlockHash,
Transaction = transaction,
TransactionResult = result
};
await executive.SetTransactionContext(txCtxt).Apply();
// TODO: Check run results / logs etc.
=======
await executive.SetTransactionContext(txCtxt).Apply();
result.Logs.AddRange(txCtxt.Trace.FlattenedLogs);
// TODO: Check run results / logs etc.
>>>>>>>
await executive.SetTransactionContext(txCtxt).Apply();
result.Logs.AddRange(txCtxt.Trace.FlattenedLogs);
// TODO: Check run results / logs etc.
<<<<<<<
// TODO: Improve log
result.Logs = ByteString.CopyFrom(Encoding.ASCII.GetBytes(ex.ToString()));
=======
// TODO: Improve log
txCtxt.Trace.StdErr += ex.ToString() + "\n";
//result.Logs = ByteString.CopyFrom(Encoding.ASCII.GetBytes(ex.ToString()));
>>>>>>>
// TODO: Improve log
txCtxt.Trace.StdErr += ex.ToString() + "\n"; |
<<<<<<<
var genTx = await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo);
// remove invalid CrossChainBlockInfoTransaction, only that from local can be executed)
/*readyTxs.RemoveAll(t =>
t.Type == TransactionType.CrossChainBlockInfoTransaction &&
!t.GetHash().Equals(genTx.GetHash()));*/
=======
Transaction genTx= await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo, _stateDictator.BlockProducerAccountAddress);
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 genTx = await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPoolService.GetReadyTxsAsync(currentRoundInfo); |
<<<<<<<
ChainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, StateManager);
_smartContractRunnerFactory = new SmartContractRunnerFactory();
var runner =
new SmartContractRunner("../../../../AElf.Runtime.CSharp.Tests.TestContract/bin/Debug/netstandard2.0/");
_smartContractRunnerFactory.AddRunner(0, runner);
=======
NewStorage();
var transactionManager = new TransactionManager(_dataStore, _logger);
var transactionTraceManager = new TransactionTraceManager(_dataStore);
_functionMetadataService = new FunctionMetadataService(_dataStore, _logger);
var chainManager = new ChainManager(_dataStore);
ChainService = new ChainService(chainManager, new BlockManager(_dataStore),
transactionManager, transactionTraceManager, _dataStore, StateStore);
_smartContractRunnerContainer = new SmartContractRunnerContainer();
var runner = new SmartContractRunner("../../../../AElf.Runtime.CSharp.Tests.TestContract/bin/Debug/netstandard2.0/");
_smartContractRunnerContainer.AddRunner(0, runner);
>>>>>>>
ChainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, StateManager);
_smartContractRunnerContainer = new SmartContractRunnerContainer();
var runner =
new SmartContractRunner("../../../../AElf.Runtime.CSharp.Tests.TestContract/bin/Debug/netstandard2.0/");
_smartContractRunnerContainer.AddRunner(0, runner);
<<<<<<<
new SmartContractService(_smartContractManager, _smartContractRunnerFactory,
StateManager, _functionMetadataService), _logger);
Task.Factory.StartNew(async () => { await Init(); }).Unwrap().Wait();
SmartContractService = new SmartContractService(_smartContractManager, _smartContractRunnerFactory,
StateManager, _functionMetadataService);
ChainService = new ChainService(_chainManager, _blockManager, _transactionManager,
_transactionTraceManager, StateManager);
=======
new SmartContractService(new SmartContractManager(_dataStore), _smartContractRunnerContainer,
StateStore, _functionMetadataService), _logger);
SmartContractManager = new SmartContractManager(_dataStore);
Task.Factory.StartNew(async () =>
{
await Init();
}).Unwrap().Wait();
SmartContractService = new SmartContractService(SmartContractManager, _smartContractRunnerContainer, StateStore, _functionMetadataService);
ChainService = new ChainService(new ChainManager(_dataStore), new BlockManager(_dataStore), new TransactionManager(_dataStore), new TransactionTraceManager(_dataStore), _dataStore, StateStore);
>>>>>>>
new SmartContractService(_smartContractManager, _smartContractRunnerContainer,
StateManager, _functionMetadataService), _logger);
Task.Factory.StartNew(async () => { await Init(); }).Unwrap().Wait();
SmartContractService = new SmartContractService(_smartContractManager, _smartContractRunnerContainer,
StateManager, _functionMetadataService);
ChainService = new ChainService(_chainManager, _blockManager, _transactionManager,
_transactionTraceManager, StateManager); |
<<<<<<<
var block = await GenerateBlock(results, currentBlockTime);
Logger.LogInformation($"Generated block {block.BlockHashToHex} at height {block.Header.Index} with {block.Body.TransactionsCount} txs.");
=======
var block = await GenerateBlock(results, sideChainTransactionsRoot, currentBlockTime);
Logger.LogInformation($"Generated block {block.BlockHashToHex} at height {block.Header.Height} with {block.Body.TransactionsCount} txs.");
>>>>>>>
var block = await GenerateBlock(results, currentBlockTime);
Logger.LogInformation($"Generated block {block.BlockHashToHex} at height {block.Header.Height} with {block.Body.TransactionsCount} txs."); |
<<<<<<<
using System.Net;
=======
using System.Linq;
using System.Net;
>>>>>>>
using System.Net;
using System.Linq;
<<<<<<<
var peer = GrpcUrl.Parse(peerConnectionIp);
if (peer == null)
return new ConnectReply { Error = ConnectError.InvalidPeer };
var error = ValidateConnectionInfo(peer, peerConnectionInfo);
=======
var error = ValidateConnectionInfo(endpoint, peerConnectionInfo);
>>>>>>>
var error = ValidateConnectionInfo(endpoint, peerConnectionInfo);
<<<<<<<
private ConnectError ValidateConnectionInfo(GrpcUrl peerEndpoint, ConnectionInfo connectionInfo)
=======
private ConnectError ValidateConnectionInfo(IPEndPoint endpoint, ConnectionInfo connectionInfo)
>>>>>>>
private ConnectError ValidateConnectionInfo(IPEndPoint endpoint, ConnectionInfo connectionInfo) |
<<<<<<<
using AElf.Kernel.Extensions;
using AElf.Kernel.Managers;
=======
using AElf.Kernel.Types;
using AElf.Kernel.Types.SmartContract;
>>>>>>>
using AElf.Kernel.Extensions;
using AElf.Kernel.Managers;
using AElf.Kernel.Types;
using AElf.Kernel.Types.SmartContract; |
<<<<<<<
private DPoS _dPoS;
=======
>>>>>>>
private DPoS _dPoS;
<<<<<<<
blockProducer.Nodes.Add(bp["pubkey"]);
}
_dPoS = new DPoS(_nodeKeyPair);
await Task.Run(() =>
{
var intervalSequnce = GetIntervalObservable();
intervalSequnce.Subscribe
(
async x =>
{
if (x == 0)
{
var txsForGenesisBlock = _dPoS.GetTxsForGenesisBlock(await GetIncrementId(_nodeKeyPair.GetAddress()), blockProducer.ToByteString());
foreach (var tx in txsForGenesisBlock)
{
await BroadcastTransaction(tx);
//executive.SetTransactionContext(new TransactionContext {Transaction = tx}).Apply(true)
//.Wait();
}
}
var block = await _miner.Mine();
_logger.Log(LogLevel.Debug, "Genereate block: {0}, with {1} transactions", block.GetHash(),
block.Body.Transactions.Count);
}
);
=======
/*try
{
await Task.Delay(5000); // secs
var block = await _miner.Mine();
_logger.Log(LogLevel.Debug, "Genereate block: {0}, with {1} transactions", block.GetHash(),
block.Body.Transactions.Count);
await BroadcastBlock(block);
}
catch (Exception e)
{
_logger.Log(LogLevel.Debug, e);
}*/
try
{
while(true)
{
await Task.Delay(10000); // secs
var block = await _miner.Mine();
_logger.Log(LogLevel.Debug, "Genereated block: {0}, with {1} transactions", block.GetHash(), block.Body.Transactions.Count);
await BroadcastBlock(block);
}
}
catch (Exception e)
{
_logger.Log(LogLevel.Debug, e);
}
>>>>>>>
blockProducer.Nodes.Add(bp["pubkey"]);
}
_dPoS = new DPoS(_nodeKeyPair);
await Task.Run(() =>
{
var intervalSequnce = GetIntervalObservable();
intervalSequnce.Subscribe
(
async x =>
{
if (x == 0)
{
var txsForGenesisBlock = _dPoS.GetTxsForGenesisBlock(await GetIncrementId(_nodeKeyPair.GetAddress()), blockProducer.ToByteString());
foreach (var tx in txsForGenesisBlock)
{
await BroadcastTransaction(tx);
//executive.SetTransactionContext(new TransactionContext {Transaction = tx}).Apply(true)
//.Wait();
}
}
var block = await _miner.Mine();
_logger.Log(LogLevel.Debug, "Genereate block: {0}, with {1} transactions", block.GetHash(),
block.Body.Transactions.Count);
}
);
<<<<<<<
private static IObservable<long> GetIntervalObservable()
{
return Observable.Interval(TimeSpan.FromMilliseconds(4000));
}
=======
public async Task<Block> GetBlockAtHeight(int height)
{
return await _blockManager.GetBlockByHeight(_nodeConfig.ChainId, (ulong)height);
}
>>>>>>>
public async Task<Block> GetBlockAtHeight(int height)
{
return await _blockManager.GetBlockByHeight(_nodeConfig.ChainId, (ulong)height);
}
private static IObservable<long> GetIntervalObservable()
{
return Observable.Interval(TimeSpan.FromMilliseconds(4000));
} |
<<<<<<<
private IBlockManager _blockManager;
private IAuthorizationInfo _authorizationInfo;
private IStateManager _stateManager;
=======
private IAuthorizationInfoReader _authorizationInfoReader;
private IStateStore _stateStore;
>>>>>>>
private IBlockManager _blockManager;
private IAuthorizationInfoReader _authorizationInfoReader;
private IStateManager _stateManager;
<<<<<<<
_chainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, _stateManager);
_smartContractRunnerFactory = new SmartContractRunnerFactory();
=======
_transactionManager = new TransactionManager(_dataStore, _logger);
_transactionReceiptManager = new TransactionReceiptManager(_database);
_smartContractManager = new SmartContractManager(_dataStore);
_transactionResultManager = new TransactionResultManager(_dataStore);
_transactionTraceManager = new TransactionTraceManager(_dataStore);
_functionMetadataService = new FunctionMetadataService(_dataStore, _logger);
_chainManager = new ChainManager(_dataStore);
_chainService = new ChainService(_chainManager, new BlockManager(_dataStore),
_transactionManager, _transactionTraceManager, _dataStore, StateStore);
_smartContractRunnerContainer = new SmartContractRunnerContainer();
>>>>>>>
_chainService = new ChainService(_chainManager, _blockManager,
_transactionManager, _transactionTraceManager, _stateManager);
_smartContractRunnerContainer = new SmartContractRunnerContainer();
<<<<<<<
new SmartContractService(_smartContractManager, _smartContractRunnerFactory, _stateManager,
_functionMetadataService), _transactionTraceManager, _stateManager,
=======
new SmartContractService(_smartContractManager, _smartContractRunnerContainer, StateStore,
_functionMetadataService), _transactionTraceManager, StateStore,
>>>>>>>
new SmartContractService(_smartContractManager, _smartContractRunnerContainer, _stateManager,
_functionMetadataService), _transactionTraceManager, _stateManager,
<<<<<<<
new SmartContractService(_smartContractManager, _smartContractRunnerFactory,
_stateManager, _functionMetadataService), _logger);
=======
new SmartContractService(_smartContractManager, _smartContractRunnerContainer,
StateStore, _functionMetadataService), _logger);
>>>>>>>
new SmartContractService(_smartContractManager, _smartContractRunnerContainer,
_stateManager, _functionMetadataService), _logger);
<<<<<<<
_authorizationInfo = new AuthorizationInfo(_stateManager);
=======
_authorizationInfoReader = new AuthorizationInfoReader(StateStore);
_stateStore = new StateStore(_database);
>>>>>>>
_authorizationInfoReader = new AuthorizationInfoReader(_stateManager);
<<<<<<<
_transactionResultManager, clientManager, _merkleTreeManager,
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfo, _signatureVerifier, _refBlockValidator, null), _chainManager, _stateManager);
=======
_transactionResultManager, clientManager, _binaryMerkleTreeManager,
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfoReader, _signatureVerifier, _refBlockValidator, null), StateStore);
>>>>>>>
_transactionResultManager, clientManager, _merkleTreeManager,
new TxHub(_transactionManager, _transactionReceiptManager, _chainService, _authorizationInfoReader, _signatureVerifier, _refBlockValidator, null), _chainManager, _stateManager); |
<<<<<<<
private readonly DPoSInfoProvider _dpoSInfoProvider;
=======
private readonly IChainManager _chainManager;
private readonly ConsensusDataProvider _consensusDataProvider;
>>>>>>>
private readonly DPoSInfoProvider _dpoSInfoProvider;
private readonly IChainManager _chainManager;
private readonly ConsensusDataProvider _consensusDataProvider;
<<<<<<<
_dpoSInfoProvider = new DPoSInfoProvider(stateStore);
=======
_consensusDataProvider = new ConsensusDataProvider(stateStore);
>>>>>>>
_dpoSInfoProvider = new DPoSInfoProvider(stateStore);
_consensusDataProvider = new ConsensusDataProvider(stateStore); |
<<<<<<<
public static int Count(this OrganizationMemberList organizationMemberList)
{
return organizationMemberList.OrganizationMembers.Count;
}
=======
>>>>>>>
<<<<<<<
public static bool AnyDuplicate(this ProposerWhiteList proposerWhiteList)
{
return proposerWhiteList.Proposers.GroupBy(p => p).Any(g => g.Count() > 1);
}
public static bool Empty(this OrganizationMemberList organizationMemberList)
{
return organizationMemberList.Count() == 0;
}
=======
>>>>>>>
public static bool AnyDuplicate(this ProposerWhiteList proposerWhiteList)
{
return proposerWhiteList.Proposers.GroupBy(p => p).Any(g => g.Count() > 1);
}
<<<<<<<
public static bool Contains(this OrganizationMemberList organizationMemberList, Address address)
{
return organizationMemberList.OrganizationMembers.Contains(address);
}
=======
>>>>>>> |
<<<<<<<
using AElf.Crosschain;
using AElf.Crosschain.Server;
=======
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
>>>>>>>
using AElf.Crosschain;
using AElf.Crosschain.Server;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions; |
<<<<<<<
using AElf.Kernel.Blockchain.Application;
using AElf.Kernel.Miner.Application;
=======
using AElf.Kernel.FeeCalculation;
using AElf.Kernel.FeeCalculation.Application;
using AElf.Kernel.Miner.Application;
>>>>>>>
using AElf.Kernel.FeeCalculation;
using AElf.Kernel.FeeCalculation.Application;
using AElf.Kernel.Blockchain.Application;
using AElf.Kernel.Miner.Application; |
<<<<<<<
MaximumLockTime = 1080,
MinimumLockTime = 90
=======
// Create Treasury profit item and register sub items.
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name,
VoteContractSystemName = VoteSmartContractAddressNameProvider.Name,
ProfitContractSystemName = ProfitSmartContractAddressNameProvider.Name,
// Get current miners.
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name,
MaximumLockTime = 1080 * 86400,
MinimumLockTime = 90 * 86400
>>>>>>>
MaximumLockTime = 1080 * 86400,
MinimumLockTime = 90 * 86400
<<<<<<<
TimeEachTerm = (int)DaysEachTerm,
BaseTimeUnit = 2 // TODO: Remove this after testing.
=======
ElectionContractSystemName = ElectionSmartContractAddressNameProvider.Name,
VoteContractSystemName = VoteSmartContractAddressNameProvider.Name,
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name,
TimeEachTerm = TimeEachTerm
>>>>>>>
TimeEachTerm = TimeEachTerm |
<<<<<<<
=======
var generatedTxn = new Transaction
{
From = FromAddress,
To = input.To,
MethodName = nameof(ACS2BaseContainer.ACS2BaseStub.GetResourceInfo),
Params = input.ToByteString(),
Signature = ByteString.CopyFromUtf8(KernelConstants.SignaturePlaceholder)
};
>>>>>>> |
<<<<<<<
=======
private int _timeoutMilliseconds;
private readonly ILogger _logger;
private readonly ClientManager _clientManager;
>>>>>>>
<<<<<<<
private IBlockChain _blockChain;
private readonly ClientManager _clientManager;
private readonly ServerManager _serverManager;
private Address _producerAddress;
private ECKeyPair _keyPair;
=======
private readonly IChainManagerBasic _chainManagerBasic;
>>>>>>>
<<<<<<<
HashHelpers.GetDisambiguationHash(await GetNewBlockIndexAsync(), Hash.FromRawBytes(_keyPair.PublicKey));
=======
HashHelpers.GetDisambiguationHash(await GetNewBlockIndexAsync(), ProducerAddress);
>>>>>>>
HashHelpers.GetDisambiguationHash(await GetNewBlockIndexAsync(), Hash.FromRawBytes(_keyPair.PublicKey));
<<<<<<<
_producerAddress = Address.Parse(NodeConfig.Instance.NodeAccount);
_blockChain = _chainService.GetBlockChain(Config.ChainId);
=======
>>>>>>>
_producerAddress = Address.Parse(NodeConfig.Instance.NodeAccount);
_blockChain = _chainService.GetBlockChain(Config.ChainId); |
<<<<<<<
using Google.Protobuf;
=======
using System;
using AElf.Common.Extensions;
using Google.Protobuf;
using static AElf.Kernel.Storages.Types;
>>>>>>>
using System;
using AElf.Common.Extensions;
using Google.Protobuf; |
<<<<<<<
using AElf.Kernel.Domain;
using AElf.Kernel.SmartContractExecution.Domain;
=======
using AElf.Kernel.Managers;
using AElf.Kernel.Services;
>>>>>>>
using AElf.Kernel.Domain;
using AElf.Kernel.SmartContractExecution.Domain;
using AElf.Kernel.Services; |
<<<<<<<
private readonly IBlockSyncStateProvider _blockSyncStateProvider;
private readonly IAnnouncementCacheProvider _announcementCacheProvider;
private readonly OSTestHelper _osTestHelper;
=======
>>>>>>>
private readonly IAnnouncementCacheProvider _announcementCacheProvider;
private readonly OSTestHelper _osTestHelper;
<<<<<<<
_blockSyncStateProvider = GetRequiredService<IBlockSyncStateProvider>();
_announcementCacheProvider = GetRequiredService<IAnnouncementCacheProvider>();
_osTestHelper = GetRequiredService<OSTestHelper>();
=======
>>>>>>>
_announcementCacheProvider = GetRequiredService<IAnnouncementCacheProvider>();
_osTestHelper = GetRequiredService<OSTestHelper>(); |
<<<<<<<
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToByteArray().ToHex());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToHex());
response.Header.MerkleTreeRootOfTransactionState.ShouldBe(block.Header.MerkleTreeRootOfTransactionStatus.ToHex());
=======
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToBase64());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToByteArray().ToHex());
response.Header.Extra.ShouldBe(block.Header.ExtraData?.ToString());
>>>>>>>
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToBase64());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToByteArray().ToHex());
response.Header.Extra.ShouldBe(block.Header.ExtraData?.ToString());
response.Header.MerkleTreeRootOfTransactionState.ShouldBe(block.Header.MerkleTreeRootOfTransactionStatus.ToHex());
<<<<<<<
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToByteArray().ToHex());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToHex());
response.Header.MerkleTreeRootOfTransactionState.ShouldBe(block.Header.MerkleTreeRootOfTransactionStatus.ToHex());
=======
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToBase64());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToByteArray().ToHex());
response.Header.Extra.ShouldBe(block.Header.ExtraData?.ToString());
>>>>>>>
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToBase64());
response.Header.SignerPubkey.ShouldBe(block.Header.SignerPubkey.ToByteArray().ToHex());
response.Header.Extra.ShouldBe(block.Header.ExtraData?.ToString());
response.Header.MerkleTreeRootOfTransactionState.ShouldBe(block.Header.MerkleTreeRootOfTransactionStatus.ToHex()); |
<<<<<<<
_smartContractService = new SmartContractService(_smartContractManager, _smartContractRunnerContainer, stateStore, _functionMetadataService, _chainService);
=======
_smartContractService = new SmartContractService(_smartContractManager, _smartContractRunnerContainer, _stateManager, _functionMetadataService);
>>>>>>>
_smartContractService = new SmartContractService(_smartContractManager, _smartContractRunnerContainer, _stateManager, _functionMetadataService, _chainService);
<<<<<<<
await txnCtxt.Trace.SmartCommitChangesAsync(_stateStore);
=======
await txnCtxt.Trace.CommitChangesAsync(_stateManager);
>>>>>>>
await txnCtxt.Trace.SmartCommitChangesAsync(_stateManager);
<<<<<<<
await txnCtxt.Trace.SmartCommitChangesAsync(_stateStore);
=======
await txnCtxt.Trace.CommitChangesAsync(_stateManager);
>>>>>>>
await txnCtxt.Trace.SmartCommitChangesAsync(_stateManager);
<<<<<<<
await txnInitCtxt.Trace.SmartCommitChangesAsync(_stateStore);
=======
await txnInitCtxt.Trace.CommitChangesAsync(_stateManager);
>>>>>>>
await txnInitCtxt.Trace.SmartCommitChangesAsync(_stateManager);
<<<<<<<
await txnPrintcxt.Trace.SmartCommitChangesAsync(_stateStore);
=======
await txnPrintcxt.Trace.CommitChangesAsync(_stateManager);
>>>>>>>
await txnPrintcxt.Trace.SmartCommitChangesAsync(_stateManager); |
<<<<<<<
private readonly IObjectMapper<ChainApplicationWebAppAElfModule> _objectMapper;
=======
private readonly ITransactionResultStatusCacheProvider _transactionResultStatusCacheProvider;
>>>>>>>
private readonly IObjectMapper<ChainApplicationWebAppAElfModule> _objectMapper;
private readonly ITransactionResultStatusCacheProvider _transactionResultStatusCacheProvider;
<<<<<<<
IBlockchainService blockchainService, IObjectMapper<ChainApplicationWebAppAElfModule> objectMapper)
=======
IBlockchainService blockchainService, ITransactionResultStatusCacheProvider transactionResultStatusCacheProvider)
>>>>>>>
IBlockchainService blockchainService, IObjectMapper<ChainApplicationWebAppAElfModule> objectMapper,
ITransactionResultStatusCacheProvider transactionResultStatusCacheProvider)
<<<<<<<
_objectMapper = objectMapper;
=======
_transactionResultStatusCacheProvider = transactionResultStatusCacheProvider;
>>>>>>>
_objectMapper = objectMapper;
_transactionResultStatusCacheProvider = transactionResultStatusCacheProvider; |
<<<<<<<
context.Services.AddAssemblyOf<CoreOSAElfModule>();
//Configure<ChainOptions>(option => option.ChainId = ChainHelpers.ConvertBase58ToChainId(configuration["ChainId"]));
=======
>>>>>>>
context.Services.AddAssemblyOf<CoreOSAElfModule>();
//Configure<ChainOptions>(option => option.ChainId = ChainHelpers.ConvertBase58ToChainId(configuration["ChainId"]));
<<<<<<<
=======
// Configure<ChainOptions>(option =>
// {
// option.ChainId = ChainHelpers.ConvertBase58ToChainId(configuration.GetSection("ChainId").Value);
// option.IsMainChain = configuration.GetSection("IsMainChain").Value.ToLower() != "false";
// });
context.Services.AddSingleton<INetworkService, NetworkService>();
>>>>>>>
<<<<<<<
=======
context.Services.AddTransient<IAccountService, AccountService>();
>>>>>>>
<<<<<<<
public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
{
var extraDataOrderInformation = context.ServiceProvider.GetService<BlockExtraDataOrderService>();
var blockExtraDataProviders = context.ServiceProvider.GetServices<IBlockExtraDataProvider>();
foreach (var blockExtraDataProvider in blockExtraDataProviders)
{
extraDataOrderInformation.AddExtraDataProvider(blockExtraDataProvider.GetType());
}
}
/*
=======
>>>>>>>
/* |
<<<<<<<
if(IsTokenDonateToTreasury(symbol))
State.DividendPoolContract.Donate.Send(new DonateInput
{
Symbol = symbol,
Amount = amount
});
else
Context.SendInline(Context.Self, nameof(Burn), new BurnInput
{
Symbol = symbol,
Amount = amount
});
=======
State.TreasuryContract.Donate.Send(new DonateInput
{
Symbol = symbol,
Amount = amount
});
>>>>>>>
State.DividendPoolContract.Donate.Send(new DonateInput
{
Symbol = symbol,
Amount = amount
});
<<<<<<<
private bool IsTokenDonateToTreasury(string symbol)
{
var tokenInfo = GetTokenInfo(new GetTokenInfoInput {Symbol = symbol});
return IsTokenProfitable(tokenInfo) || State.LockWhiteLists[symbol][State.DividendPoolContract.Value];
}
=======
>>>>>>>
<<<<<<<
var treasuryContractAddress =
Context.GetContractAddressByName(SmartContractConstants.TreasuryContractSystemName);
if (treasuryContractAddress != null && IsTokenDonateToTreasury(symbol))
=======
var isMainChain = Context.GetContractAddressByName(SmartContractConstants.TreasuryContractSystemName) !=
null;
if (isMainChain)
>>>>>>>
var treasuryContractAddress =
Context.GetContractAddressByName(SmartContractConstants.TreasuryContractSystemName);
var isMainChain = treasuryContractAddress != null;
if (isMainChain)
<<<<<<<
Assert(tokenWeightInfo.AddedTokenWeight > 0 && tokenWeightInfo.BaseTokenWeight > 0,
$"symbol:{tokenWeightInfo.TokenSymbol} weight should be greater than 0");
var tokenInfo = State.TokenInfos[tokenWeightInfo.TokenSymbol];
Assert(tokenInfo != null, $"Token is not found. {tokenWeightInfo.TokenSymbol}");
// ReSharper disable once PossibleNullReferenceException
Assert(IsTokenProfitable(tokenInfo), $"Token {tokenWeightInfo.TokenSymbol} is not Profitable");
=======
var tokenInfo = State.TokenInfos[tokenSymbol];
if (tokenInfo == null)
{
throw new AssertionException($"Token is not found. {tokenSymbol}");
}
Assert(tokenInfo.IsProfitable && tokenInfo.IsBurnable, $"Token {tokenSymbol} cannot set as method fee.");
totalSupply = tokenInfo.TotalSupply;
>>>>>>>
var tokenInfo = State.TokenInfos[tokenSymbol];
if (tokenInfo == null)
{
throw new AssertionException($"Token is not found. {tokenSymbol}");
}
Assert(IsTokenAvailableForMethodFee(new StringValue{Value = tokenSymbol}).Value, $"Token {tokenSymbol} cannot set as method fee.");
totalSupply = tokenInfo.TotalSupply; |
<<<<<<<
using AElf.Types;
=======
using AElf.Kernel.Infrastructure;
>>>>>>>
using AElf.Types;
using AElf.Kernel.Infrastructure; |
<<<<<<<
mockService.Setup(m => m.DoHandshakeAsync(It.IsAny<DnsEndPoint>(), It.IsAny<Handshake>()))
.Returns<DnsEndPoint, Handshake>(async (pe, hsk) =>
=======
mockService.Setup(m => m.DoHandshakeAsync(It.IsAny<IPEndPoint>(), It.IsAny<Handshake>()))
.Returns<IPEndPoint, Handshake>((pe, hsk) =>
>>>>>>>
mockService.Setup(m => m.DoHandshakeAsync(It.IsAny<DnsEndPoint>(), It.IsAny<Handshake>()))
.Returns<DnsEndPoint, Handshake>((pe, hsk) => |
<<<<<<<
=======
private IBackgroundJobStore _jobStore;
private readonly LastIrreversibleBlockJob _job;
>>>>>>>
<<<<<<<
_kernelTestHelper = GetRequiredService<KernelTestHelper>();
_smartContractAddressService.SetAddress(ConsensusSmartContractAddressNameProvider.Name,
_consensusAddress);
=======
_transactionResultService = GetRequiredService<ITransactionResultService>();
_jobStore = GetRequiredService<IBackgroundJobStore>();
_job = GetRequiredService<LastIrreversibleBlockJob>();
>>>>>>>
_kernelTestHelper = GetRequiredService<KernelTestHelper>();
_smartContractAddressService.SetAddress(ConsensusSmartContractAddressNameProvider.Name,
_consensusAddress);
_jobStore = GetRequiredService<IBackgroundJobStore>();
_job = GetRequiredService<LastIrreversibleBlockJob>();
<<<<<<<
=======
await PrepareTestData();
>>>>>>>
<<<<<<<
var transaction = _kernelTestHelper.GenerateTransaction();
=======
var transaction = GenerateTransaction();
>>>>>>>
var transaction = _kernelTestHelper.GenerateTransaction();
<<<<<<<
var transaction = _kernelTestHelper.GenerateTransaction();
=======
var transaction = GenerateTransaction();
>>>>>>>
var transaction = _kernelTestHelper.GenerateTransaction();
<<<<<<<
var transaction = _kernelTestHelper.GenerateTransaction();
=======
var transaction = GenerateTransaction();
var offset = 5;
>>>>>>>
var transaction = _kernelTestHelper.GenerateTransaction();
var offset = 5;
<<<<<<<
var transactionResult =
_kernelTestHelper.GenerateTransactionResult(transaction, TransactionResultStatus.Mined, logEvent);
var newBlock = await _kernelTestHelper.AttachBlock(chain.BestChainHeight, chain.BestChainHash,
new List<Transaction> {transaction}, new List<TransactionResult> {transactionResult});
=======
var transactionResult = GenerateTransactionResult(transaction, TransactionResultStatus.Mined, logEvent);
var newBlock = await AttachBlock(chain.BestChainHeight, chain.BestChainHash, transaction,
transactionResult);
>>>>>>>
var transactionResult =
_kernelTestHelper.GenerateTransactionResult(transaction, TransactionResultStatus.Mined, logEvent);
var newBlock = await _kernelTestHelper.AttachBlock(chain.BestChainHeight, chain.BestChainHash,
new List<Transaction> {transaction}, new List<TransactionResult> {transactionResult});
<<<<<<<
=======
#region private methods
/// <summary>
/// Create new chain, attach 10 blocks, set best chain and set lib.
/// </summary>
/// <returns>
/// BestChainHeight: 11
/// LongestChainHeight: 11
/// LibHeight: 5
/// </returns>
private async Task<Chain> PrepareTestData()
{
var genesisBlock = new Block
{
Header = new BlockHeader
{
Height = ChainConsts.GenesisBlockHeight,
PreviousBlockHash = Hash.Empty
},
Body = new BlockBody()
};
var chain = await _blockchainService.CreateChainAsync(genesisBlock);
_smartContractAddressService.SetAddress(ConsensusSmartContractAddressNameProvider.Name,
_consensusAddress);
var currentHeight = chain.BestChainHeight;
var currentHash = chain.BestChainHash;
for (var i = 0; i < 10; i++)
{
var transaction = GenerateTransaction();
var transactionResult = GenerateTransactionResult(transaction, TransactionResultStatus.Mined);
var block = await AttachBlock(currentHeight, currentHash, transaction, transactionResult);
currentHeight = block.Height;
currentHash = block.GetHash();
chain = await _blockchainService.GetChainAsync();
await _blockchainService.SetBestChainAsync(chain, currentHeight, currentHash);
if (currentHeight < 6)
{
await _blockchainService.SetIrreversibleBlockAsync(chain, currentHeight, currentHash);
}
}
return chain;
}
private Transaction GenerateTransaction()
{
var transaction = new Transaction
{
From = Address.Zero,
To = Address.Zero,
MethodName = Guid.NewGuid().ToString()
};
return transaction;
}
private TransactionResult GenerateTransactionResult(Transaction transaction, TransactionResultStatus status,
LogEvent logEvent = null)
{
var transactionResult = new TransactionResult
{
TransactionId = transaction.GetHash(),
Status = status
};
if (logEvent != null)
{
transactionResult.Logs.Add(logEvent);
}
return transactionResult;
}
private async Task<Block> AttachBlock(long previousBlockHeight, Hash previousBlockHash,
Transaction transaction, TransactionResult transactionResult)
{
var newBlock = new Block
{
Header = new BlockHeader
{
Height = previousBlockHeight + 1,
PreviousBlockHash = previousBlockHash,
Time = Timestamp.FromDateTime(DateTime.UtcNow)
},
Body = new BlockBody()
};
newBlock.AddTransaction(transaction);
newBlock.Header.MerkleTreeRootOfTransactions = newBlock.Body.CalculateMerkleTreeRoots();
await _blockchainService.AddBlockAsync(newBlock);
var chain = await _blockchainService.GetChainAsync();
await _blockchainService.AttachBlockToChainAsync(chain, newBlock);
await _transactionResultService.AddTransactionResultAsync(transactionResult, newBlock.Header);
return newBlock;
}
#endregion
>>>>>>> |
<<<<<<<
using AElf.TestBase;
=======
using AElf.Kernel.Managers;
using AElf.Kernel.SmartContract;
using FunctionMetadata = AElf.Kernel.SmartContract.FunctionMetadata;
>>>>>>>
using AElf.TestBase;
using AElf.Kernel.Managers;
using AElf.Kernel.SmartContract;
using FunctionMetadata = AElf.Kernel.SmartContract.FunctionMetadata;
<<<<<<<
public sealed class ChainFunctionMetadataTest : AElfKernelIntegratedTest
{
private readonly IDataStore _dataStore;
=======
[UseAutofacTestFramework]
public class ChainFunctionMetadataTest
{
>>>>>>>
public sealed class ChainFunctionMetadataTest : AElfKernelIntegratedTest
{ |
<<<<<<<
internal TokenContractContainer.TokenContractStub AuthorizedTokenContractStub =>
GetTester<TokenContractContainer.TokenContractStub>(TokenContractAddress, ManagerKeyPair);
internal TokenConverterContractImplContainer.TokenConverterContractImplStub DefaultStub =>
GetTester<TokenConverterContractImplContainer.TokenConverterContractImplStub>(TokenConverterContractAddress,
=======
internal TokenConverterContractContainer.TokenConverterContractStub DefaultStub =>
GetTester<TokenConverterContractContainer.TokenConverterContractStub>(TokenConverterContractAddress,
>>>>>>>
internal TokenConverterContractImplContainer.TokenConverterContractImplStub DefaultStub =>
GetTester<TokenConverterContractImplContainer.TokenConverterContractImplStub>(TokenConverterContractAddress,
<<<<<<<
internal TokenConverterContractImplContainer.TokenConverterContractImplStub AuthorizedTokenConvertStub =>
GetTester<TokenConverterContractImplContainer.TokenConverterContractImplStub>(TokenConverterContractAddress,
ManagerKeyPair);
internal ParliamentContractImplContainer.ParliamentContractImplStub ParliamentContractStub =>
=======
internal ParliamentContractContainer.ParliamentContractStub ParliamentContractStub =>
>>>>>>>
internal ParliamentContractImplContainer.ParliamentContractImplStub ParliamentContractStub =>
<<<<<<<
internal ParliamentContractImplContainer.ParliamentContractImplStub GetParliamentContractTester(
=======
internal ParliamentContractContainer.ParliamentContractStub GetParliamentContractTester(
>>>>>>>
internal ParliamentContractImplContainer.ParliamentContractImplStub GetParliamentContractTester( |
<<<<<<<
private readonly ITransactionFeeExemptionService _transactionFeeExemptionService;
=======
private readonly ICalculateFeeService _calService;
>>>>>>>
private readonly ICalculateFeeService _calService;
private readonly ITransactionFeeExemptionService _transactionFeeExemptionService;
<<<<<<<
ITransactionSizeFeeUnitPriceProvider transactionSizeFeeUnitPriceProvider,
ITransactionFeeExemptionService transactionFeeExemptionService)
=======
ITransactionSizeFeeUnitPriceProvider transactionSizeFeeUnitPriceProvider,
ICalculateFeeService calService)
>>>>>>>
ITransactionSizeFeeUnitPriceProvider transactionSizeFeeUnitPriceProvider,
ITransactionFeeExemptionService transactionFeeExemptionService,
ICalculateFeeService calService)
<<<<<<<
_transactionFeeExemptionService = transactionFeeExemptionService;
=======
_calService = calService;
>>>>>>>
_calService = calService;
_transactionFeeExemptionService = transactionFeeExemptionService;
<<<<<<<
return new List<Transaction>();
=======
context.GetZeroSmartContractAddress(context.ChainId),
context.GetContractAddressByName(TokenSmartContractAddressNameProvider.Name),
// TODO: Try to use contract address name providers - put providers to one place easy to ref.
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.Consensus")),
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.CrossChain")),
context.GetContractAddressByName(Hash.FromString("AElf.ContractNames.Economic")),
};
if (systemContractAddresses.Contains(transactionContext.Transaction.To))
{
if (_systemTransactionMethodNameListProvider.GetSystemTransactionMethodNameList()
.Contains(transactionContext.Transaction.MethodName))
{
return new List<Transaction>();
}
var methodNameWhiteList = new List<string>
{
nameof(TokenContractContainer.TokenContractStub.Create),
nameof(TokenContractContainer.TokenContractStub.Issue),
nameof(TokenContractContainer.TokenContractStub.CrossChainTransfer),
nameof(TokenContractContainer.TokenContractStub.CrossChainReceiveToken),
nameof(TokenContractContainer.TokenContractStub.CheckResourceToken),
nameof(TokenContractContainer.TokenContractStub.ChargeResourceToken),
"IssueNativeToken"
};
if (methodNameWhiteList.Contains(transactionContext.Transaction.MethodName))
{
return new List<Transaction>();
}
>>>>>>>
return new List<Transaction>(); |
<<<<<<<
$"Remaining tickets of {bv.Value.ToByteArray().ToPlainBase58()}: {tickets.TotalTickets}");
=======
$"Remaining tickets of {bv.Value.ToByteArray().ToHex()}: {tickets.RemainingTickets}");
>>>>>>>
$"Remaining tickets of {bv.Value.ToByteArray().ToHex()}: {tickets.TotalTickets}");
<<<<<<<
$"Remaining tickets of {bv.Value.ToByteArray().ToPlainBase58()}: {tickets.TotalTickets}");
=======
$"Remaining tickets of {bv.Value.ToByteArray().ToHex()}: {tickets.RemainingTickets}");
>>>>>>>
$"Remaining tickets of {bv.Value.ToByteArray().ToHex()}: {tickets.TotalTickets}"); |
<<<<<<<
_accountService = accountService;
=======
_lazyStateProvider = new Lazy<IStateProvider>(
() => new CachedStateProvider(
new StateProvider() {HostSmartContractBridgeContext = this}),
LazyThreadSafetyMode.PublicationOnly);
>>>>>>>
_accountService = accountService;
_lazyStateProvider = new Lazy<IStateProvider>(
() => new CachedStateProvider(
new StateProvider() {HostSmartContractBridgeContext = this}),
LazyThreadSafetyMode.PublicationOnly); |
<<<<<<<
{
QueryFilter filter = new QueryFilter();
filter.andFilters["AgentID"] = AgentID;
if (data.Query(new string[1] { "*" }, "osagent", filter, null, null, null).Count != 0)
{
data.Update("osagent", new object[] { GroupID }, new[] { "ActiveGroupID" }, new[] { "AgentID" }, new object[] { AgentID });
}
=======
{
object remoteValue = DoRemote(AgentID, GroupID);
if (remoteValue != null || m_doRemoteOnly)
return (string)remoteValue;
if (data.Query("AgentID", AgentID, "osagent", "*").Count != 0)
data.Update("osagent", new object[] {GroupID}, new[] {"ActiveGroupID"}, new[] {"AgentID"},
new object[] {AgentID});
>>>>>>>
{
object remoteValue = DoRemote(AgentID, GroupID);
if (remoteValue != null || m_doRemoteOnly)
return (string)remoteValue;
QueryFilter filter = new QueryFilter();
filter.andFilters["AgentID"] = AgentID;
if (data.Query(new string[1] { "*" }, "osagent", filter, null, null, null).Count != 0)
{
data.Update("osagent", new object[] { GroupID }, new[] { "ActiveGroupID" }, new[] { "AgentID" }, new object[] { AgentID });
}
<<<<<<<
{
QueryFilter filter = new QueryFilter();
filter.andFilters["AgentID"] = AgentID;
List<string> groups = data.Query(new string[1] { "ActiveGroupID" }, "osagent", filter, null, null, null);
return (groups.Count != 0) ? UUID.Parse(groups[0]) : UUID.Zero;
}
=======
{
object remoteValue = DoRemote(RequestingAgentID, AgentID);
if (remoteValue != null || m_doRemoteOnly)
return (UUID)remoteValue;
List<string> groups = data.Query("AgentID", AgentID, "osagent", "ActiveGroupID");
if (groups.Count != 0)
return UUID.Parse(groups[0]);
else
return UUID.Zero;
}
[CanBeReflected(ThreatLevel = OpenSim.Services.Interfaces.ThreatLevel.Low)]
public string SetAgentGroupSelectedRole(UUID AgentID, UUID GroupID, UUID RoleID)
{
object remoteValue = DoRemote(AgentID, GroupID, RoleID);
if (remoteValue != null || m_doRemoteOnly)
return (string)remoteValue;
>>>>>>>
{
object remoteValue = DoRemote(RequestingAgentID, AgentID);
if (remoteValue != null || m_doRemoteOnly)
return (UUID)remoteValue;
QueryFilter filter = new QueryFilter();
filter.andFilters["AgentID"] = AgentID;
List<string> groups = data.Query(new string[1] { "ActiveGroupID" }, "osagent", filter, null, null, null);
return (groups.Count != 0) ? UUID.Parse(groups[0]) : UUID.Zero;
}
[CanBeReflected(ThreatLevel = OpenSim.Services.Interfaces.ThreatLevel.Low)]
public string SetAgentGroupSelectedRole(UUID AgentID, UUID GroupID, UUID RoleID)
{
object remoteValue = DoRemote(AgentID, GroupID, RoleID);
if (remoteValue != null || m_doRemoteOnly)
return (string)remoteValue;
<<<<<<<
public void AddAgentToGroup(UUID requestingAgentID, UUID AgentID, UUID GroupID, UUID RoleID)
{
Dictionary<string, object> where = new Dictionary<string, object>(2);
where["AgentID"] = AgentID;
where["GroupID"] = GroupID;
if (data.Query(new string[1] { "*" }, "osgroupmembership", new QueryFilter
{
andFilters = where
}, null, null, null).Count != 0)
=======
if (data.Query(new[]
{
"AgentID",
"GroupID"
}, new object[]
{
AgentID,
GroupID
}, "osgroupmembership", "*").Count != 0)
>>>>>>>
Dictionary<string, object> where = new Dictionary<string, object>(2);
where["AgentID"] = AgentID;
where["GroupID"] = GroupID;
if (data.Query(new string[1] { "*" }, "osgroupmembership", new QueryFilter
{
andFilters = where
}, null, null, null).Count != 0)
<<<<<<<
public List<GroupMembershipData> GetAgentGroupMemberships(UUID requestingAgentID, UUID AgentID)
{
Dictionary<string, object> where = new Dictionary<string, object>(1);
where["AgentID"] = AgentID;
List<string> Groups = data.Query(new string[1] { "GroupID" }, "osgroupmembership", new QueryFilter
{
andFilters = where
}, null, null, null);
=======
List<string> Groups = data.Query(new[]
{
"AgentID"
}, new object[]
{
AgentID
}, "osgroupmembership", "GroupID");
>>>>>>>
Dictionary<string, object> where = new Dictionary<string, object>(1);
where["AgentID"] = AgentID;
List<string> Groups = data.Query(new string[1] { "GroupID" }, "osgroupmembership", new QueryFilter
{
andFilters = where
}, null, null, null);
<<<<<<<
public List<GroupInviteInfo> GetGroupInvites(UUID requestingAgentID)
{
Dictionary<string, object> where = new Dictionary<string, object>(1);
where["AgentID"] = requestingAgentID;
List<string> groupInvite = data.Query(new string[1] { "*" }, "osgroupinvite", new QueryFilter
{
andFilters = where
}, null, null, null);
=======
List<string> groupInvite = data.Query(new[]
{
"AgentID"
}, new object[]
{
requestingAgentID
}, "osgroupinvite", "*");
>>>>>>>
Dictionary<string, object> where = new Dictionary<string, object>(1);
where["AgentID"] = requestingAgentID;
List<string> groupInvite = data.Query(new string[1] { "*" }, "osgroupinvite", new QueryFilter
{
andFilters = where
}, null, null, null);
<<<<<<<
public GroupMembersData GetAgentGroupMemberData(UUID requestingAgentID, UUID GroupID, UUID AgentID)
{
Dictionary<string, object> where = new Dictionary<string, object>(2);
where["GroupID"] = GroupID;
where["AgentID"] = requestingAgentID;
=======
>>>>>>>
Dictionary<string, object> where = new Dictionary<string, object>(2);
where["GroupID"] = GroupID;
where["AgentID"] = requestingAgentID;
<<<<<<<
public List<GroupMembersData> GetGroupMembers(UUID requestingAgentID, UUID GroupID)
{
if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong)GroupPowers.None))
{
return new List<GroupMembersData>(0);
}
=======
if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong) GroupPowers.None))
return new List<GroupMembersData>();
>>>>>>>
if (!CheckGroupPermissions(requestingAgentID, GroupID, (ulong)GroupPowers.None))
{
return new List<GroupMembersData>(0);
}
<<<<<<<
public List<DirGroupsReplyData> FindGroups(UUID requestingAgentID, string search, int StartQuery, uint queryflags)
{
QueryFilter filter = new QueryFilter();
filter.andLikeFilters["Name"] = "%" + search.MySqlEscape(50) + "%";
List<string> retVal = data.Query(new string[5]{
"GroupID",
"Name",
"ShowInList",
"AllowPublish",
"MaturePublish"
}, "osgroup", filter, null, (uint)StartQuery, 50);
=======
string whereClause = " Name LIKE '%" + search.MySqlEscape(50) + "%' LIMIT " + StartQuery + ",50 ";
List<string> retVal = data.Query(whereClause, "osgroup",
"GroupID,Name,ShowInList,AllowPublish,MaturePublish");
>>>>>>>
QueryFilter filter = new QueryFilter();
filter.andLikeFilters["Name"] = "%" + search.MySqlEscape(50) + "%";
List<string> retVal = data.Query(new string[5]{
"GroupID",
"Name",
"ShowInList",
"AllowPublish",
"MaturePublish"
}, "osgroup", filter, null, (uint)StartQuery, 50);
<<<<<<<
public GroupNoticeInfo GetGroupNotice(UUID requestingAgentID, UUID noticeID)
{
QueryFilter filter = new QueryFilter();
filter.andFilters["NoticeID"] = noticeID;
List<string> notice = data.Query(new string[9]{
"GroupID",
"Timestamp",
"FromName",
"Subject",
"ItemID",
"HasAttachment",
"Message",
"AssetType",
"ItemName"
}, "osgroupnotice", filter, null, null, null);
=======
List<string> notice = data.Query("NoticeID", noticeID, "osgroupnotice",
"GroupID,Timestamp,FromName,Subject,ItemID,HasAttachment,Message,AssetType,ItemName");
>>>>>>>
QueryFilter filter = new QueryFilter();
filter.andFilters["NoticeID"] = noticeID;
List<string> notice = data.Query(new string[9]{
"GroupID",
"Timestamp",
"FromName",
"Subject",
"ItemID",
"HasAttachment",
"Message",
"AssetType",
"ItemName"
}, "osgroupnotice", filter, null, null, null); |
<<<<<<<
private readonly ICalculateStrategyProvider _calculateStrategyProvider;
=======
private readonly ITransactionFeeExemptionService _transactionFeeExemptionService;
>>>>>>>
private readonly ICalculateStrategyProvider _calculateStrategyProvider;
private readonly ITransactionFeeExemptionService _transactionFeeExemptionService;
<<<<<<<
ICalculateFeeService calService,
ICalculateStrategyProvider calculateStrategyProvider)
=======
ITransactionSizeFeeUnitPriceProvider transactionSizeFeeUnitPriceProvider,
ITransactionFeeExemptionService transactionFeeExemptionService,
ICalculateFeeService calService)
>>>>>>>
ITransactionFeeExemptionService transactionFeeExemptionService,
ICalculateFeeService calService,
ICalculateStrategyProvider calculateStrategyProvider)
<<<<<<<
_calculateStrategyProvider = calculateStrategyProvider;
=======
_transactionFeeExemptionService = transactionFeeExemptionService;
>>>>>>>
_calculateStrategyProvider = calculateStrategyProvider;
_transactionFeeExemptionService = transactionFeeExemptionService;
<<<<<<<
var chainContext = new ChainContext
{
BlockHash = transactionContext.PreviousBlockHash,
BlockHeight = transactionContext.BlockHeight - 1
};
var txCalculateStrategy = _calculateStrategyProvider.GetTxCalculateStrategy();
_calService.CalculateCostStrategy = txCalculateStrategy;
var txCost = await _calService.CalculateFee(chainContext, txSize);
=======
var txCost = _calService.CalculateFee(FeeType.Tx, txSize);
>>>>>>>
var chainContext = new ChainContext
{
BlockHash = transactionContext.PreviousBlockHash,
BlockHeight = transactionContext.BlockHeight - 1
};
var txCalculateStrategy = _calculateStrategyProvider.GetTxCalculateStrategy();
_calService.CalculateCostStrategy = txCalculateStrategy;
var txCost = await _calService.CalculateFee(chainContext, txSize); |
<<<<<<<
using System;
using System.Threading.Tasks;
using AElf.Kernel.Storages;
using Google.Protobuf.WellKnownTypes;
using AElf.Common;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
namespace AElf.Kernel.Managers
{
public class BlockManager : IBlockManager
{
private readonly IDataStore _dataStore;
public ILogger<BlockManager> Logger {get;set;}
public BlockManager(IDataStore dataStore)
{
_dataStore = dataStore;
Logger = NullLogger<BlockManager>.Instance;
}
public async Task<IBlock> AddBlockAsync(IBlock block)
{
await _dataStore.InsertAsync(block.GetHash().OfType(HashType.BlockHeaderHash), block.Header);
await _dataStore.InsertAsync(block.GetHash().OfType(HashType.BlockBodyHash), block.Body);
return block;
}
public async Task AddBlockBodyAsync(Hash blockHash, BlockBody blockBody)
{
await _dataStore.InsertAsync(blockHash.Clone().OfType(HashType.BlockBodyHash), blockBody);
}
public async Task<BlockHeader> GetBlockHeaderAsync(Hash blockHash)
{
return await _dataStore.GetAsync<BlockHeader>(blockHash.Clone().OfType(HashType.BlockHeaderHash));
}
public async Task<BlockBody> GetBlockBodyAsync(Hash bodyHash)
{
return await _dataStore.GetAsync<BlockBody>(bodyHash.Clone().OfType(HashType.BlockBodyHash));
}
public async Task<BlockHeader> AddBlockHeaderAsync(BlockHeader header)
{
await _dataStore.InsertAsync(header.GetHash().OfType(HashType.BlockHeaderHash), header);
return header;
}
public async Task<Block> GetBlockAsync(Hash blockHash)
{
try
{
var header = await _dataStore.GetAsync<BlockHeader>(blockHash.Clone().OfType(HashType.BlockHeaderHash));
var bb = await _dataStore.GetAsync<BlockBody>(blockHash.Clone().OfType(HashType.BlockBodyHash));
if (header == null || bb == null)
return null;
return new Block { Header = header, Body = bb };
}
catch (Exception e)
{
Logger.LogError(e, $"Error while getting block {blockHash.ToHex()}.");
return null;
}
}
/// <summary>
/// Bind child chain height with parent height who indexed it.
/// </summary>
/// <param name="chainId"></param>
/// <param name="childHeight"></param>
/// <param name="parentHeight"></param>
/// <returns></returns>
public async Task BindParentChainHeight(Hash chainId, ulong childHeight, ulong parentHeight)
{
var key = DataPath.CalculatePointerForParentChainHeightByChildChainHeight(chainId, childHeight);
await _dataStore.InsertAsync(key, new UInt64Value {Value = parentHeight});
}
/// <summary>
/// Get the parent chain block height indexing the child chain <param name="childHeight"/>.
/// </summary>
/// <param name="chainId"></param>
/// <param name="childHeight"></param>
/// <returns></returns>
public async Task<ulong> GetBoundParentChainHeight(Hash chainId, ulong childHeight)
{
var key = DataPath.CalculatePointerForParentChainHeightByChildChainHeight(chainId, childHeight);
return (await _dataStore.GetAsync<UInt64Value>(key))?.Value ?? 0;
}
public async Task<Block> GetNextBlockOf(Hash chainId, Hash blockHash)
{
var nextBlockHeight = (await GetBlockHeaderAsync(blockHash)).Index + 1;
var nextBlockHash = await _dataStore.GetAsync<Hash>(
DataPath.CalculatePointerForGettingBlockHashByHeight(chainId, nextBlockHeight));
return await GetBlockAsync(nextBlockHash);
}
public async Task<Block> GetBlockByHeight(Hash chainId, ulong height)
{
Logger.LogTrace($"Trying to get block by height {height}.");
var key = DataPath.CalculatePointerForGettingBlockHashByHeight(chainId, height);
if (key == null)
{
Logger.LogError($"Invalid block height - {height}.");
return null;
}
var blockHash = await _dataStore.GetAsync<Hash>(key);
var blockHeader = await _dataStore.GetAsync<BlockHeader>(blockHash.OfType(HashType.BlockHeaderHash));
var blockBody = await _dataStore.GetAsync<BlockBody>(blockHash.OfType(HashType.BlockBodyHash));
return new Block
{
Header = blockHeader,
Body = blockBody
};
}
}
=======
using System;
using System.Threading.Tasks;
using AElf.Common;
using AElf.Kernel.Storages;
using NLog;
namespace AElf.Kernel.Managers
{
public class BlockManager : IBlockManager
{
private readonly IBlockHeaderStore _blockHeaderStore;
private readonly IBlockBodyStore _blockBodyStore;
private readonly ILogger _logger;
public BlockManager(IBlockHeaderStore blockHeaderStore, IBlockBodyStore blockBodyStore)
{
_blockHeaderStore = blockHeaderStore;
_blockBodyStore = blockBodyStore;
_logger = LogManager.GetLogger(nameof(BlockManager));
}
public async Task AddBlockAsync(IBlock block)
{
await AddBlockHeaderAsync(block.Header);
await AddBlockBodyAsync(block.GetHash(), block.Body);
}
public async Task AddBlockHeaderAsync(BlockHeader header)
{
await _blockHeaderStore.SetAsync(header.GetHash().ToHex(), header);
}
public async Task AddBlockBodyAsync(Hash blockHash, BlockBody blockBody)
{
blockBody.TransactionList.Clear();
await _blockBodyStore.SetAsync(blockHash.Clone().ToHex(), blockBody);
}
public async Task<Block> GetBlockAsync(Hash blockHash)
{
try
{
var header = await GetBlockHeaderAsync(blockHash);
var bb = await GetBlockBodyAsync(blockHash);
if (header == null || bb == null)
return null;
return new Block { Header = header, Body = bb };
}
catch (Exception e)
{
_logger.Error(e, $"Error while getting block {blockHash.ToHex()}.");
return null;
}
}
public async Task<BlockHeader> GetBlockHeaderAsync(Hash blockHash)
{
return await _blockHeaderStore.GetAsync<BlockHeader>(blockHash.ToHex());
}
public async Task<BlockBody> GetBlockBodyAsync(Hash bodyHash)
{
return await _blockBodyStore.GetAsync<BlockBody>(bodyHash.ToHex());
}
}
>>>>>>>
using System;
using System.Threading.Tasks;
using AElf.Kernel.Storages;
using Google.Protobuf.WellKnownTypes;
using AElf.Common;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
namespace AElf.Kernel.Managers
{
public class BlockManager : IBlockManager
{
private readonly IBlockHeaderStore _blockHeaderStore;
private readonly IBlockBodyStore _blockBodyStore;
public ILogger<BlockManager> Logger {get;set;}
public BlockManager(IBlockHeaderStore blockHeaderStore, IBlockBodyStore blockBodyStore)
{
Logger = NullLogger<BlockManager>.Instance;
_blockHeaderStore = blockHeaderStore;
_blockBodyStore = blockBodyStore;
}
public async Task AddBlockAsync(IBlock block)
{
await AddBlockHeaderAsync(block.Header);
await AddBlockBodyAsync(block.GetHash(), block.Body);
}
public async Task AddBlockHeaderAsync(BlockHeader header)
{
await _blockHeaderStore.SetAsync(header.GetHash().ToHex(), header);
}
public async Task AddBlockBodyAsync(Hash blockHash, BlockBody blockBody)
{
blockBody.TransactionList.Clear();
await _blockBodyStore.SetAsync(blockHash.Clone().ToHex(), blockBody);
}
public async Task<Block> GetBlockAsync(Hash blockHash)
{
try
{
var header = await GetBlockHeaderAsync(blockHash);
var bb = await GetBlockBodyAsync(blockHash);
if (header == null || bb == null)
return null;
return new Block { Header = header, Body = bb };
}
catch (Exception e)
{
Logger.LogError(e, $"Error while getting block {blockHash.ToHex()}.");
return null;
}
}
public async Task<BlockHeader> GetBlockHeaderAsync(Hash blockHash)
{
return await _blockHeaderStore.GetAsync<BlockHeader>(blockHash.ToHex());
}
public async Task<BlockBody> GetBlockBodyAsync(Hash bodyHash)
{
return await _blockBodyStore.GetAsync<BlockBody>(bodyHash.ToHex());
}
} |
<<<<<<<
if (remoteValue != null)
{
=======
if (remoteValue != null || m_doRemoteOnly)
>>>>>>>
if (remoteValue != null || m_doRemoteOnly)
{
<<<<<<<
if (remoteValue != null)
{
=======
if (remoteValue != null || m_doRemoteOnly)
>>>>>>>
if (remoteValue != null || m_doRemoteOnly)
{
<<<<<<<
if (remoteValue != null)
{
=======
if (remoteValue != null || m_doRemoteOnly)
>>>>>>>
if (remoteValue != null || m_doRemoteOnly)
{ |
<<<<<<<
private ISmartContractRunnerFactory _smartContractRunnerFactory;
public ILogger<MockSetup> Logger {get;set;}
=======
private ISmartContractRunnerContainer _smartContractRunnerContainer;
private ILogger _logger;
>>>>>>>
public ILogger<MockSetup> Logger {get;set;}
private ISmartContractRunnerContainer _smartContractRunnerContainer;
<<<<<<<
new SmartContractService(new SmartContractManager(_dataStore), _smartContractRunnerFactory,
StateStore, _functionMetadataService));
=======
new SmartContractService(new SmartContractManager(_dataStore), _smartContractRunnerContainer,
StateStore, _functionMetadataService), _logger);
>>>>>>>
new SmartContractService(new SmartContractManager(_dataStore), _smartContractRunnerContainer,
StateStore, _functionMetadataService)); |
<<<<<<<
var firstRound = _consensusContract.GetRoundInfo(1);
=======
var firstRound= _contracts.GetRoundInfo(1);
>>>>>>>
var firstRound = _contracts.GetRoundInfo(1);
<<<<<<<
Assert.Equal(GlobalConfig.InValueNotMatchToOutValue,
_consensusContract.TransactionContext.Trace.StdErr);
=======
Assert.Equal(GlobalConfig.InValueNotMatchToOutValue, _contracts.TransactionContext.Trace.StdErr);
>>>>>>>
Assert.Equal(GlobalConfig.InValueNotMatchToOutValue,
_contracts.TransactionContext.Trace.StdErr);
<<<<<<<
var firstRound = _consensusContract.GetRoundInfo(1);
=======
var firstRound = _contracts.GetRoundInfo(1);
>>>>>>>
var firstRound = _contracts.GetRoundInfo(1);
<<<<<<<
_consensusContract.BroadcastInValue(keyPair, new ToBroadcast
=======
_contracts.BroadcastInValue(keyPair, new ToBroadcast
>>>>>>>
_contracts.BroadcastInValue(keyPair, new ToBroadcast
<<<<<<<
Assert.Equal(string.Empty, _consensusContract.TransactionContext.Trace.StdErr);
=======
Assert.Equal(string.Empty, _contracts.TransactionContext.Trace.StdErr);
>>>>>>>
Assert.Equal(string.Empty, _contracts.TransactionContext.Trace.StdErr);
<<<<<<<
return _consensusContract.GetRoundInfo(1);
=======
return _contracts.GetRoundInfo(1);
>>>>>>>
return _contracts.GetRoundInfo(1); |
<<<<<<<
=======
using AElf.Common;
using AElf.CrossChain.Cache;
using AElf.CrossChain.Grpc;
using AElf.CrossChain.Grpc.Server;
>>>>>>>
<<<<<<<
{
[DependsOn(typeof(KernelAElfModule))]
public class CrossChainAElfModule : AElfModule
{
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddTransient<IBlockExtraDataProvider, CrossChainBlockExtraDataProvider>();
context.Services.AddTransient<ISystemTransactionGenerator, CrossChainIndexingTransactionGenerator>();
context.Services.AddTransient<IBlockValidationProvider, CrossChainValidationProvider>();
}
}
}
=======
{
[DependsOn(typeof(KernelAElfModule))]
public class CrossChainAElfModule : AElfModule
{
public override void ConfigureServices(ServiceConfigurationContext context)
{
var services = context.Services;
services.AddAssemblyOf<CrossChainAElfModule>();
services.AddSingleton<CrossChainBlockDataRpcServer>();
var configuration = context.Services.GetConfiguration();
Configure<GrpcConfigOption>(configuration.GetSection("CrossChain"));
services.AddSingleton<ICrossChainDataProvider, CrossChainDataProvider>();
services.AddScoped<ISystemTransactionGenerator, CrossChainIndexingTransactionGenerator>();
services.AddScoped<IBlockExtraDataProvider, CrossChainExtraDataProvider>();
services.AddScoped<IBlockValidationProvider, CrossChainValidationProvider>();
services.AddSingleton<ICrossChainService, CrossChainService>();
services.AddTransient<ISmartContractAddressNameProvider, CrossChainSmartContractAddressNameProvider>();
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
// var opt = context.ServiceProvider.GetService<IOptionsSnapshot<GrpcConfigOption>>().Value;
// var clientService = context.ServiceProvider.GetService<GrpcProducerConsumerService>();
// // Init client connected to parent chain if it exists.
// clientService.Init(opt.CertificateDir);
// if (!string.IsNullOrEmpty(opt.ParentChainId) && !string.IsNullOrEmpty(opt.ParentChainNodeIp) &&
// !string.IsNullOrEmpty(opt.ParentChainPort)) return;
// var blockInfoCache = new BlockInfoCache(opt.ParentChainId.ConvertBase58ToChainId());
// clientService.CreateConsumerProducer(new CrossChainDataProducer
// {
// TargetIp = opt.ParentChainNodeIp,
// TargetPort = uint.Parse(opt.ParentChainPort),
// SideChainId = opt.ParentChainId.ConvertBase58ToChainId(),
// TargetIsSideChain = false,
// BlockInfoCache = blockInfoCache
// });
// context.ServiceProvider.GetService<CrossChainDataProvider>().ParentChainBlockInfoCache =
// blockInfoCache;
}
}
}
>>>>>>>
{
[DependsOn(typeof(KernelAElfModule))]
public class CrossChainAElfModule : AElfModule
{
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.AddTransient<IBlockExtraDataProvider, CrossChainBlockExtraDataProvider>();
context.Services.AddTransient<ISystemTransactionGenerator, CrossChainIndexingTransactionGenerator>();
context.Services.AddTransient<IBlockValidationProvider, CrossChainValidationProvider>();
context.Services.AddTransient<ISmartContractAddressNameProvider, CrossChainSmartContractAddressNameProvider>();
}
}
} |
<<<<<<<
private async Task VoteToReferendum(Hash input)
=======
private async Task VoteToReferendum(Hash input, string primaryTokenSymbol)
>>>>>>>
private async Task VoteToReferendum(Hash input, string primaryTokenSymbol)
<<<<<<<
var parliamentCreateProposalResult = await ParliamentContractStub.CreateProposal.SendAsync(parliamentProposal);
var parliamentProposalId = parliamentCreateProposalResult.Output;
await ApproveWithMinersAsync(parliamentProposalId);
var ret = await ReleaseProposalAsync(parliamentProposalId);
var id = ProposalCreated.Parser
=======
var parliamentCreateProposal = await MainChainTester.ExecuteContractWithMiningAsync(ParliamentAddress,
nameof(ParliamentContractContainer.ParliamentContractStub.CreateProposal),
parliamentProposal);
parliamentCreateProposal.Status.ShouldBe(TransactionResultStatus.Mined);
var parliamentProposalId = new Hash();
parliamentProposalId.MergeFrom(parliamentCreateProposal.ReturnValue);
await ApproveWithMinersAsync(parliamentProposalId, ParliamentAddress, MainChainTester);
var ret = await ReleaseProposalAsync(parliamentProposalId, ParliamentAddress, MainChainTester);
var referendumProposalId = ProposalCreated.Parser
>>>>>>>
var parliamentCreateProposalResult = await ParliamentContractStub.CreateProposal.SendAsync(parliamentProposal);
var parliamentProposalId = parliamentCreateProposalResult.Output;
await ApproveWithMinersAsync(parliamentProposalId);
var ret = await ReleaseProposalAsync(parliamentProposalId);
var referendumProposalId = ProposalCreated.Parser
<<<<<<<
await ReferendumContractStub.Approve.SendAsync(id);
=======
var proposalVirtualAddress = await MainChainTester.ExecuteContractWithMiningAsync(ReferendumAddress,
nameof(ReferendumContractContainer.ReferendumContractStub.GetProposalVirtualAddress), referendumProposalId);
var approveResult = await MainChainTester.ExecuteContractWithMiningAsync(TokenContractAddress,
nameof(TokenContractImplContainer.TokenContractImplStub.Approve), new ApproveInput
{
Spender = Address.Parser.ParseFrom(proposalVirtualAddress.ReturnValue),
Symbol = primaryTokenSymbol,
Amount = 100000
});
approveResult.Status.ShouldBe(TransactionResultStatus.Mined);
await MainChainTester.ExecuteContractWithMiningAsync(ReferendumAddress,
nameof(ReferendumContractContainer.ReferendumContractStub.Approve),
referendumProposalId);
>>>>>>>
var proposalVirtualAddress = await ReferendumContractStub.GetProposalVirtualAddress.CallAsync(referendumProposalId);
await TokenContractStub.Approve.SendAsync(new ApproveInput
{
Spender = proposalVirtualAddress,
Symbol = primaryTokenSymbol,
Amount = 100000
});
await ReferendumContractStub.Approve.SendAsync(referendumProposalId);
<<<<<<<
ToAddress = ReferendumContractAddress,
Params = id.ToByteString(),
=======
ToAddress = ReferendumAddress,
Params = referendumProposalId.ToByteString(),
>>>>>>>
ToAddress = ReferendumContractAddress,
Params = referendumProposalId.ToByteString(),
<<<<<<<
private async Task CreateAndIssueVoteToken()
=======
private async Task<string> CreateAndIssueToken()
>>>>>>>
private async Task<string> CreateAndIssueToken()
<<<<<<<
await TokenContractStub.Issue.SendAsync(new IssueInput
{
Amount = 100000,
To = callOwner,
Symbol = symbol.Value
});
await TokenContractStub.Approve.SendAsync(new ApproveInput
{
Spender = ReferendumContractAddress,
Symbol = symbol.Value,
Amount = 100000
});
=======
var issueResult = await MainChainTester.ExecuteContractWithMiningAsync(TokenContractAddress,
nameof(TokenContractImplContainer.TokenContractImplStub.Issue), new IssueInput
{
Amount = 100000,
To = callOwner,
Symbol = symbol.Value
});
issueResult.Status.ShouldBe(TransactionResultStatus.Mined);
return symbol.Value;
>>>>>>>
var issueResult = await TokenContractStub.Issue.SendAsync(new IssueInput
{
Amount = 100000,
To = callOwner,
Symbol = symbol.Value
});
issueResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
return symbol.Value; |
<<<<<<<
=======
context.Services.AddSingleton<AnnouncementReceivedEventHandler>();
context.Services.AddSingleton<PeerDiscoveryWorker>();
>>>>>>>
context.Services.AddSingleton<PeerDiscoveryWorker>(); |
<<<<<<<
} while (reExecutionResult1.IsFailed() && !_miningStarted);
Thread.VolatileWrite(ref _flag, 0);
=======
} while (reExecutionResult1.CanExecuteAgain() && !_miningStarted);
>>>>>>>
} while (reExecutionResult1.CanExecuteAgain() && !_miningStarted);
Thread.VolatileWrite(ref _flag, 0);
<<<<<<<
Thread.Sleep(100);
} while (reExecutionResult2.IsFailed());
=======
} while (reExecutionResult2.CanExecuteAgain());
>>>>>>>
} while (reExecutionResult2.CanExecuteAgain()); |
<<<<<<<
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachReceivedBlockAsync(peerBlock),
KernelConsts.UpdateChainQueueName);
=======
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachBlockAsync(peerBlock),
KernelConstants.UpdateChainQueueName);
>>>>>>>
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachReceivedBlockAsync(peerBlock),
KernelConstants.UpdateChainQueueName);
<<<<<<<
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachReceivedBlockAsync(block),
KernelConsts.UpdateChainQueueName);
=======
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachBlockAsync(block),
KernelConstants.UpdateChainQueueName);
>>>>>>>
_taskQueueManager.Enqueue(async () => await _blockAttachService.AttachReceivedBlockAsync(block),
KernelConstants.UpdateChainQueueName); |
<<<<<<<
var blocks = new List<Block>();
for (var i = currentHeight; i > height; i--)
{
var block = await GetBlockByHeightAsync(i);
var body = block.Body;
foreach (var txId in body.Transactions)
{
var tx = await _transactionManager.GetTransaction(txId);
txs.Add(tx);
}
var h = GetHeightHash(i).OfType(HashType.CanonicalHash);
await _dataStore.RemoveAsync<Hash>(h);
await RollbackStateForBlock(block);
blocks.Add((Block) block);
}
=======
var h = GetHeightHash(i).OfType(HashType.CanonicalHash);
await _dataStore.RemoveAsync<Hash>(h);
await RollbackSideChainInfo(block);
await RollbackStateForBlock(block);
blocks.Add((Block)block);
}
>>>>>>>
var blocks = new List<Block>();
for (var i = currentHeight; i > height; i--)
{
var block = await GetBlockByHeightAsync(i);
var body = block.Body;
foreach (var txId in body.Transactions)
{
var tx = await _transactionManager.GetTransaction(txId);
txs.Add(tx);
}
var h = GetHeightHash(i).OfType(HashType.CanonicalHash);
await _dataStore.RemoveAsync<Hash>(h);
await RollbackSideChainInfo(block);
await RollbackStateForBlock(block);
blocks.Add((Block)block);
}
<<<<<<<
MessageHub.Instance.Publish(new BranchRolledBack(blocks));
_logger?.Trace("Finished rollback to " + height);
MessageHub.Instance.Publish(new RollBackStateChanged(false));
=======
MessageHub.Instance.Publish(new BranchRolledBack(blocks));
_logger?.Trace("Finished rollback to " + height);
MessageHub.Instance.Publish(new RollBackStateChanged(false));
MessageHub.Instance.Publish(new CatchingUpAfterRollback(true));
>>>>>>>
MessageHub.Instance.Publish(new BranchRolledBack(blocks));
_logger?.Trace("Finished rollback to " + height);
MessageHub.Instance.Publish(new RollBackStateChanged(false));
MessageHub.Instance.Publish(new CatchingUpAfterRollback(true)); |
<<<<<<<
=======
/// <summary>
/// Initialize a profit contract.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public override Empty InitializeProfitContract(Empty input)
{
Assert(!State.Initialized.Value, "Already initialized.");
State.Initialized.Value = true;
return new Empty();
}
/// <summary>
/// Create a ProfitItem
/// At the first time,the profitItem's id is unknown,it may create by transaction id and createdProfitIds;
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
>>>>>>>
/// <summary>
/// Create a ProfitItem
/// At the first time,the profitItem's id is unknown,it may create by transaction id and createdProfitIds;
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
<<<<<<<
public override Empty SetTreasuryProfitId(Hash input)
{
Assert(State.TreasuryProfitId.Value == null, "Treasury profit id already set.");
State.TreasuryProfitId.Value = input;
return new Empty();
}
=======
/// <summary>
/// Register a SubProfitItem,binding to a ProfitItem as child.
/// Then add the father ProfitItem's weight.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
>>>>>>>
public override Empty SetTreasuryProfitId(Hash input)
{
Assert(State.TreasuryProfitId.Value == null, "Treasury profit id already set.");
State.TreasuryProfitId.Value = input;
return new Empty();
}
/// <summary>
/// Register a SubProfitItem,binding to a ProfitItem as child.
/// Then add the father ProfitItem's weight.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
<<<<<<<
Context.LogDebug(() => $"Entered ReleaseProfit. {input.ProfitId}");
if (State.TokenContract.Value == null)
{
State.TokenContract.Value =
Context.GetContractAddressByName(SmartContractConstants.TokenContractSystemName);
}
=======
Assert(input.Amount >= 0, $"Amount must greater than 0");
>>>>>>>
Context.LogDebug(() => $"Entered ReleaseProfit. {input.ProfitId}");
if (State.TokenContract.Value == null)
{
State.TokenContract.Value =
Context.GetContractAddressByName(SmartContractConstants.TokenContractSystemName);
}
Assert(input.Amount >= 0, $"Amount must greater than 0");
<<<<<<<
Context.LogDebug(() => $"Sub profit items count: {profitItem.SubProfitItems.Count}");
=======
//according to the ratio that subProfitItem's weight divide totalWeight,subProfitItem can get the corresponding token.
>>>>>>>
Context.LogDebug(() => $"Sub profit items count: {profitItem.SubProfitItems.Count}");
//according to the ratio that subProfitItem's weight divide totalWeight,subProfitItem can get the corresponding token. |
<<<<<<<
ISmartContractRunnerFactory smartContractRunnerFactory,
=======
ISmartContractRunnerContainer smartContractRunnerContainer, ILogger logger,
>>>>>>>
ISmartContractRunnerContainer smartContractRunnerContainer, |
<<<<<<<
=======
private const string GetTxResultMethodName = "get_tx_result";
>>>>>>>
private const string GetTxResultMethodName = "get_tx_result";
<<<<<<<
BroadcastBlockMethodName,
GetContractAbi
=======
BroadcastBlockMethodName,
GetTxResultMethodName
>>>>>>>
BroadcastBlockMethodName,
GetContractAbi,
GetTxResultMethodName
<<<<<<<
case GetTxMethodName:
responseData = await ProcessGetTx(reqParams);
break;
case InsertTxMethodName:
responseData = await ProcessInsertTx(reqParams);
break;
case BroadcastTxMethodName:
responseData = await ProcessBroadcastTx(reqParams);
break;
case GetPeersMethodName:
responseData = await ProcessGetPeers(reqParams);
break;
case GetCommandsMethodName:
responseData = ProcessGetCommands();
break;
case GetIncrementIdMethodName:
responseData = await ProcessGetIncrementId(reqParams);
break;
case BroadcastBlockMethodName:
responseData = await ProcessBroadcastBlock(reqParams);
break;
case GetContractAbi:
responseData = await ProcessGetContractAbi(reqParams);
break;
default:
Console.WriteLine("Method name not found"); // todo log
break;
=======
case GetTxMethodName:
responseData = await ProcessGetTx(reqParams);
break;
case InsertTxMethodName:
responseData = await ProcessInsertTx(reqParams);
break;
case BroadcastTxMethodName:
responseData = await ProcessBroadcastTx(reqParams);
break;
case GetPeersMethodName:
responseData = await ProcessGetPeers(reqParams);
break;
case GetCommandsMethodName:
responseData = ProcessGetCommands();
break;
case GetIncrementIdMethodName:
responseData = await ProcessGetIncrementId(reqParams);
break;
case BroadcastBlockMethodName:
responseData = await ProcessBroadcastBlock(reqParams);
break;
case GetTxResultMethodName:
responseData = await ProcGetTxResult(reqParams);
break;
default:
Console.WriteLine("Method name not found"); // todo log
break;
>>>>>>>
case GetTxMethodName:
responseData = await ProcessGetTx(reqParams);
break;
case InsertTxMethodName:
responseData = await ProcessInsertTx(reqParams);
break;
case BroadcastTxMethodName:
responseData = await ProcessBroadcastTx(reqParams);
break;
case GetPeersMethodName:
responseData = await ProcessGetPeers(reqParams);
break;
case GetCommandsMethodName:
responseData = ProcessGetCommands();
break;
case GetIncrementIdMethodName:
responseData = await ProcessGetIncrementId(reqParams);
break;
case BroadcastBlockMethodName:
responseData = await ProcessBroadcastBlock(reqParams);
break;
case GetContractAbi:
responseData = await ProcessGetContractAbi(reqParams);
break;
case GetTxResultMethodName:
responseData = await ProcGetTxResult(reqParams);
break;
default:
Console.WriteLine("Method name not found"); // todo log
break; |
<<<<<<<
services.AddSingleton<IBlockAcceptedLogEventHandler, TransactionFeeCalculatorCoefficientUpdatedEventHandle>();
services.AddSingleton<IBlockAcceptedLogEventHandler, SymbolListToPayTxFeeUpdatedEventHandler>();
=======
services.AddSingleton<IBlockAcceptedLogEventProcessor, TransactionFeeCalculatorCoefficientUpdatedLogEventProcessor>();
services.AddSingleton<IBlockAcceptedLogEventProcessor, SymbolListToPayTxFeeUpdatedLogEventProcessor>();
services.AddSingleton<ICalculateStorageCostStrategy, StorageCalculateCostStrategy>();
services.AddSingleton<ICalculateReadCostStrategy, ReadCalculateCostStrategy>();
services.AddSingleton<ICalculateTrafficCostStrategy, TrafficCalculateCostStrategy>();
services.AddSingleton<ICalculateWriteCostStrategy, WriteCalculateCostStrategy>();
services.AddSingleton<ICalculateTxCostStrategy, TxCalculateCostStrategy>();
>>>>>>>
services.AddSingleton<IBlockAcceptedLogEventProcessor, TransactionFeeCalculatorCoefficientUpdatedLogEventProcessor>();
services.AddSingleton<IBlockAcceptedLogEventProcessor, SymbolListToPayTxFeeUpdatedLogEventProcessor>(); |
<<<<<<<
using AElf.Contracts.CrossChain;
=======
using AElf.Contracts.Genesis;
>>>>>>>
using AElf.Contracts.Genesis;
using AElf.Contracts.CrossChain;
<<<<<<<
public MappedState<Hash, CrossChainReceiveTokenInput> VerifiedCrossChainTransferTransaction { get; set; }
public CrossChainContractReferenceState CrossChainContractReferenceState { get; set; }
public SingletonState<Hash> CrossChainContractSystemName { get; set; }
public BasicContractZeroReferenceState BasicContractZero { get; set; }
=======
internal BasicContractZeroContainer.BasicContractZeroReferenceState BasicContractZero { get; set; }
>>>>>>>
internal BasicContractZeroContainer.BasicContractZeroReferenceState BasicContractZero { get; set; }
public MappedState<Hash, CrossChainReceiveTokenInput> VerifiedCrossChainTransferTransaction { get; set; }
public CrossChainContractReferenceState CrossChainContractReferenceState { get; set; }
public SingletonState<Hash> CrossChainContractSystemName { get; set; }
public BasicContractZeroReferenceState BasicContractZero { get; set; } |
<<<<<<<
Logger.LogTrace("UpdateConsensus - Update");
=======
_amIMined = true;
_logger?.Trace("UpdateConsensus - Update");
>>>>>>>
Logger.LogTrace("UpdateConsensus - Update");
_amIMined = true;
<<<<<<<
private async Task<Transaction> GenerateNormalTransactionAsync(string methodName, List<object> parameters)
{
try
{
var bn = await BlockChain.GetCurrentBlockHeightAsync();
bn = bn > 4 ? bn - 4 : 0;
var bh = bn == 0 ? Hash.Genesis : (await BlockChain.GetHeaderByHeightAsync(bn)).GetHash();
var bhPref = bh.Value.Where((x, i) => i < 4).ToArray();
var tx = new Transaction
{
From = Address.FromPublicKey(_ownPubKey),
To = TokenContractAddress,
RefBlockNumber = bn,
RefBlockPrefix = ByteString.CopyFrom(bhPref),
MethodName = methodName,
Type = TransactionType.ContractTransaction,
Params = ByteString.CopyFrom(ParamsPacker.Pack(parameters.ToArray()))
};
var signer = new ECSigner();
var signature = signer.Sign(_nodeKey, tx.GetHash().DumpByteArray());
tx.Sigs.Add(ByteString.CopyFrom(signature.SigBytes));
return tx;
}
catch (Exception e)
{
Logger.LogTrace(e, "Error while during generating normal tx.");
}
return null;
}
=======
>>>>>>>
<<<<<<<
// TODO: Recover after testing
if (/*(calculatedAge % GlobalConfig.DaysEachTerm == 0 &&
calculatedAge / GlobalConfig.DaysEachTerm <= LatestTermNumber) ||*/
(LatestRoundNumber / GlobalConfig.RoundsPerTerm + 1 != LatestTermNumber &&
_helper.TryToGetVictories(out var victories) &&
victories.Count == GlobalConfig.BlockProducerNumber))
{
Logger.LogTrace("Will change term.");
throw new NextTermException();
}
=======
Thread.VolatileWrite(ref _lockFlag, 0);
MessageHub.Instance.Publish(new DPoSStateChanged(behavior, false));
_logger?.Trace($"Mine - Leaving DPoS Mining Process - {behavior.ToString()}.");
_logger?.Trace("Will change term.");
ConsensusDisposable?.Dispose();
ConsensusDisposable = ConsensusObserver.NextTerm();
return;
>>>>>>>
Thread.VolatileWrite(ref _lockFlag, 0);
MessageHub.Instance.Publish(new DPoSStateChanged(behavior, false));
Logger.LogTrace($"Mine - Leaving DPoS Mining Process - {behavior.ToString()}.");
Logger.LogTrace("Will change term.");
ConsensusDisposable?.Dispose();
ConsensusDisposable = ConsensusObserver.NextTerm();
return;
<<<<<<<
Logger.LogTrace($"Mine - Leaving DPoS Mining Process - {behavior.ToString()}.");
if (goNextTerm)
{
ConsensusDisposable?.Dispose();
ConsensusDisposable = ConsensusObserver.NextTerm();
}
=======
_logger?.Trace($"Mine - Leaving DPoS Mining Process - {behavior.ToString()}.");
>>>>>>>
Logger.LogTrace($"Mine - Leaving DPoS Mining Process - {behavior.ToString()}.");
<<<<<<<
//MessageHub.Instance.Publish(new MinorityForkDetected());
Logger.LogDebug("Finished Launching events.");
=======
MessageHub.Instance.Publish(new MinorityForkDetected());
>>>>>>>
MessageHub.Instance.Publish(new MinorityForkDetected()); |
<<<<<<<
using AElf.Kernel.SmartContract.Application;
=======
using AElf.Kernel.Blockchain.Application;
>>>>>>>
using AElf.Kernel.SmartContract.Application;
using AElf.Kernel.Blockchain.Application; |
<<<<<<<
public override AmountAndTimeProportion GetAmountAndTimeProportionOfVoteWeight(Empty input)
{
return State.AmountAndTimeProportion.Value ?? GetDefaultAmountAndTimeProportion();
}
=======
public override SymbolList GetDistributingSymbolList(Empty input)
{
return State.SymbolList.Value;
}
>>>>>>>
public override AmountAndTimeProportion GetAmountAndTimeProportionOfVoteWeight(Empty input)
{
return State.AmountAndTimeProportion.Value ?? GetDefaultAmountAndTimeProportion();
}
public override SymbolList GetDistributingSymbolList(Empty input)
{
return State.SymbolList.Value;
} |
<<<<<<<
typeof(AElf.Miner.Rpc.MinerRpcAElfModule),
typeof(CoreKernelAElfModule)
=======
typeof(KernelAElfModule)
>>>>>>>
typeof(CoreKernelAElfModule) |
<<<<<<<
nameof(ISmartContractZero.DeploySmartContract), DefaultCategory,
File.ReadAllBytes(typeof(TokenContract).Assembly.Location));
=======
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = 3,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
>>>>>>>
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = DefaultCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
<<<<<<<
var bytes = await Tester.CallContractMethodAsync(BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySystemSmartContract), new SystemContractDeploymentInput
{
Category = DefaultCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
}
);
// Failed to deploy.
Assert.Empty(bytes);
=======
var bytes1 = await Tester.CallContractMethodAsync(BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = 3,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
var otherKeyPair = CryptoHelpers.GenerateKeyPair();
var other = Tester.CreateNewContractTester(otherKeyPair);
var bytes2 = await other.CallContractMethodAsync(
BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = 3,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
bytes1.ShouldNotBeSameAs(bytes2);
>>>>>>>
var bytes = await Tester.CallContractMethodAsync(BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySystemSmartContract), new SystemContractDeploymentInput
{
Category = DefaultCategory,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
}
);
// Failed to deploy.
Assert.Empty(bytes);
var bytes1 = await Tester.CallContractMethodAsync(BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = 3,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
var otherKeyPair = CryptoHelpers.GenerateKeyPair();
var other = Tester.CreateNewContractTester(otherKeyPair);
var bytes2 = await other.CallContractMethodAsync(
BasicZeroContractAddress,
nameof(ISmartContractZero.DeploySmartContract),
new ContractDeploymentInput()
{
Category = 3,
Code = ByteString.CopyFrom(File.ReadAllBytes(typeof(TokenContract).Assembly.Location))
});
bytes1.ShouldNotBeSameAs(bytes2);
<<<<<<<
});
var result = GetBalanceOutput.Parser.ParseFrom(bytes);
=======
}));
>>>>>>>
}));
<<<<<<<
{
var resultGetBytes = await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
});
var resultGet = GetMethodFeeOutput.Parser.ParseFrom(resultGetBytes);
resultGet.Fee.ShouldBe(0L);
}
=======
var resultGet = GetMethodFeeOutput.Parser.ParseFrom(
await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
}));
resultGet.Fee.ShouldBe(0L);
>>>>>>>
{
var resultGetBytes = await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
});
var resultGet = GetMethodFeeOutput.Parser.ParseFrom(resultGetBytes);
resultGet.Fee.ShouldBe(0L);
}
<<<<<<<
{
var resultGetBytes = await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
});
var resultGet = GetMethodFeeOutput.Parser.ParseFrom(resultGetBytes);
resultGet.Fee.ShouldBe(10L);
}
=======
var resultGet1 = GetMethodFeeOutput.Parser.ParseFrom(
await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
}));
resultGet1.Fee.ShouldBe(10L);
>>>>>>>
{
var resultGetBytes = await Tester.CallContractMethodAsync(TokenContractAddress,
nameof(TokenContract.GetMethodFee), new GetMethodFeeInput
{
Method = nameof(TokenContract.Transfer)
});
var resultGet = GetMethodFeeOutput.Parser.ParseFrom(resultGetBytes);
resultGet.Fee.ShouldBe(10L);
} |
<<<<<<<
public void Remove(TKey key)
{
if (!Cache.TryGetValue(key, out var valuePair))
{
valuePair = LoadKey(key);
Cache[key] = valuePair;
}
valuePair.IsDeleted = true;
}
=======
public void Set(TKey key, TEntity value)
{
var valuePair = new ValuePair
{
OriginalValue = default(TEntity),
Value = default(TEntity)
};
Cache[key] = valuePair;
valuePair.Value = value;
}
>>>>>>>
public void Remove(TKey key)
{
if (!Cache.TryGetValue(key, out var valuePair))
{
valuePair = LoadKey(key);
Cache[key] = valuePair;
}
valuePair.IsDeleted = true;
}
public void Set(TKey key, TEntity value)
{
var valuePair = new ValuePair
{
OriginalValue = default(TEntity),
Value = default(TEntity)
};
Cache[key] = valuePair;
valuePair.Value = value;
} |
<<<<<<<
private readonly IStaticChainInformationProvider _staticChainInformationProvider;
private OsBlockchainNodeContext _blockchainNodeCtxt;
=======
private readonly IBlockAttachService _blockAttachService;
>>>>>>>
private readonly IStaticChainInformationProvider _staticChainInformationProvider;
private readonly IBlockAttachService _blockAttachService;
private OsBlockchainNodeContext _blockchainNodeCtxt; |
<<<<<<<
public class ServerServiceTestBase : AElfIntegratedTest<ConnectionServiceTestModule>
{
}
=======
public class GrpcNetworkDialerTestBase : AElfIntegratedTest<GrpcNetworkDialerTestModule>
{}
>>>>>>>
public class GrpcNetworkDialerTestBase : AElfIntegratedTest<GrpcNetworkDialerTestModule>
{}
public class ServerServiceTestBase : AElfIntegratedTest<ConnectionServiceTestModule>
{
} |
<<<<<<<
using AElf.Kernel.Consensus.Application;
using AElf.Kernel.TransactionPool.Application;
=======
>>>>>>>
using AElf.Kernel.TransactionPool.Application;
<<<<<<<
private readonly ITransactionInclusivenessProvider _transactionInclusivenessProvider;
private readonly IMiningService _miningService;
=======
private readonly IMiningService _miningService;
>>>>>>>
private readonly ITransactionInclusivenessProvider _transactionInclusivenessProvider;
private readonly IMiningService _miningService; |
<<<<<<<
context.Services.AddSingleton<ITransactionInclusivenessProvider, TransactionInclusivenessProvider>();
context.Services.RemoveAll<IPreExecutionPlugin>();
=======
context.Services.AddSingleton<ITransactionPackingService, TransactionPackingService>();
context.Services.AddSingleton<ISecretSharingService, SecretSharingService>();
context.Services.AddSingleton<IInValueCacheService, InValueCacheService>();
>>>>>>>
context.Services.AddSingleton<ITransactionPackingService, TransactionPackingService>();
context.Services.AddSingleton<ISecretSharingService, SecretSharingService>();
context.Services.AddSingleton<IInValueCacheService, InValueCacheService>();
context.Services.RemoveAll<IPreExecutionPlugin>(); |
<<<<<<<
=======
private async Task SetBestChainAsync(List<ChainBlockLink> successLinks, Chain chain)
{
if (successLinks.Count == 0)
return;
Logger.LogDebug($"Set best chain for block height {string.Join(",", successLinks.Select(l => l.Height))}");
var blockLink = successLinks.Last();
await _blockchainService.SetBestChainAsync(chain, blockLink.Height, blockLink.BlockHash);
}
public async Task<List<ChainBlockLink>> ExecuteBlocksAttachedToLongestChain(Chain chain,
BlockAttachOperationStatus status)
{
//TODO: split the logic of getting blocks to execute, and the logic of executing blocks, and the logic of mark blocks executed
//only keep the logic of executing blocks here
if (!status.HasFlag(BlockAttachOperationStatus.LongestChainFound))
{
Logger.LogDebug($"Try to attach to chain but the status is {status}.");
return null;
}
var successLinks = new List<ChainBlockLink>();
var successBlockExecutedSets = new List<BlockExecutedSet>();
var blockLinks = await _chainManager.GetNotExecutedBlocks(chain.LongestChainHash);
try
{
foreach (var blockLink in blockLinks)
{
var linkedBlock = await _blockchainService.GetBlockByHashAsync(blockLink.BlockHash);
var blockExecutedSet = await ProcessBlockAsync(linkedBlock);
if (blockExecutedSet == null)
{
await _chainManager.SetChainBlockLinkExecutionStatusAsync(blockLink,
ChainBlockLinkExecutionStatus.ExecutionFailed);
await _chainManager.RemoveLongestBranchAsync(chain);
return null;
}
successLinks.Add(blockLink);
successBlockExecutedSets.Add(blockExecutedSet);
Logger.LogInformation(
$"Executed block {blockLink.BlockHash} at height {blockLink.Height}, with {linkedBlock.Body.TransactionsCount} txns.");
await LocalEventBus.PublishAsync(new BlockAcceptedEvent {BlockExecutedSet = blockExecutedSet});
}
}
catch (BlockValidationException ex)
{
if (!(ex.InnerException is ValidateNextTimeBlockValidationException))
{
await _chainManager.RemoveLongestBranchAsync(chain);
throw;
}
Logger.LogWarning(
$"Block validation failed: {ex.Message}. Inner exception {ex.InnerException.Message}");
}
catch (Exception ex)
{
await _chainManager.RemoveLongestBranchAsync(chain);
Logger.LogError(ex, "Block validate or execute fails.");
throw;
}
if (successLinks.Count == 0 || successLinks.Last().Height < chain.BestChainHeight)
{
Logger.LogWarning("No block execution succeed or no block is higher than best chain.");
await _chainManager.RemoveLongestBranchAsync(chain);
return null;
}
await SetBestChainAsync(successLinks, chain);
await _chainManager.SetChainBlockLinkExecutionStatusesAsync(successLinks,
ChainBlockLinkExecutionStatus.ExecutionSuccess);
await LocalEventBus.PublishAsync(new BlocksExecutionSucceededEvent
{
BlockExecutedSets = successBlockExecutedSets
});
Logger.LogInformation(
$"Attach blocks to best chain, status: {status}, best chain hash: {chain.BestChainHash}, height: {chain.BestChainHeight}");
return blockLinks;
}
>>>>>>> |
<<<<<<<
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
=======
var randomHashes = Enumerable.Range(0, AEDPoSContractTestConstants.InitialMinersCount).Select(_ => Hash.FromString("hash")).ToList();
var triggers = Enumerable.Range(0, AEDPoSContractTestConstants.InitialMinersCount).Select(i => new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialMinersKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
>>>>>>>
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
<<<<<<<
var oneCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[1]);
var randomHash = Hash.Generate();
=======
var oneCandidate = GetAEDPoSContractStub(CandidatesKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractStub(CandidatesKeyPairs[1]);
var randomHash = Hash.FromString("hash2");
>>>>>>>
var oneCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[1]);
var randomHash = Hash.FromString("hash2");
<<<<<<<
RandomHash = Hash.Generate(), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
=======
RandomHash = Hash.FromString("hash3"), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(CandidatesKeyPairs[0].PublicKey)
>>>>>>>
RandomHash = Hash.FromString("hash3"), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
<<<<<<<
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.Generate()).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
=======
var randomHashes = Enumerable.Range(0, AEDPoSContractTestConstants.InitialMinersCount).Select(_ => Hash.FromString("hash3")).ToList();
var triggers = Enumerable.Range(0, AEDPoSContractTestConstants.InitialMinersCount).Select(i => new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialMinersKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
>>>>>>>
var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(_ => Hash.FromString("hash3")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
<<<<<<<
var oneCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[1]);
var randomHash = Hash.Generate();
var informationOfSecondRound = (await AEDPoSContractStub.GetInformationToUpdateConsensus.CallAsync(
=======
var oneCandidate = GetAEDPoSContractStub(CandidatesKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractStub(CandidatesKeyPairs[1]);
var randomHash = Hash.FromString("hash5");
var informationOfSecondRound = (await oneCandidate.GetInformationToUpdateConsensus.CallAsync(
>>>>>>>
var oneCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[0]);
var anotherCandidate = GetAEDPoSContractTester(ValidationDataCenterKeyPairs[1]);
var randomHash = Hash.FromString("hash5");
var informationOfSecondRound = (await AEDPoSContractStub.GetInformationToUpdateConsensus.CallAsync(
<<<<<<<
RandomHash = Hash.Generate(), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey)
=======
RandomHash = Hash.FromString("hash6"), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(CandidatesKeyPairs[0].PublicKey)
>>>>>>>
RandomHash = Hash.FromString("RandomHash"), // Don't care this value in current test case.
Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey) |
<<<<<<<
// Api.Assert(ValidateMiners(term.FirstRound),
// $"Miners list is wrong of round {term.FirstRound.RoundNumber}.");
// Api.Assert(ValidateMiners(term.SecondRound),
// $"Miners list is wrong of round {term.SecondRound.RoundNumber}.");
=======
var stopwatch = new Stopwatch();
stopwatch.Start();
// TODO: Check the miners are correct.
>>>>>>>
var stopwatch = new Stopwatch();
stopwatch.Start();
// TODO: Check the miners are correct.
<<<<<<<
if (IsMainchain() && forwarding.NextRoundInfo.MinersHash() != GetCurrentRoundInfo().MinersHash() &&
=======
var stopwatch = new Stopwatch();
stopwatch.Start();
Api.Assert(
forwarding.NextRoundInfo.RoundNumber == 0 || _collection.CurrentRoundNumberField.GetValue() <
forwarding.NextRoundInfo.RoundNumber,
"Incorrect round number of next round.");
if (forwarding.NextRoundInfo.MinersHash() != GetCurrentRoundInfo().MinersHash() &&
>>>>>>>
var stopwatch = new Stopwatch();
stopwatch.Start();
Api.Assert(
forwarding.NextRoundInfo.RoundNumber == 0 || _collection.CurrentRoundNumberField.GetValue() <
forwarding.NextRoundInfo.RoundNumber,
"Incorrect round number of next round.");
if (IsMainchain() && forwarding.NextRoundInfo.MinersHash() != GetCurrentRoundInfo().MinersHash() &&
<<<<<<<
// When the node is in Round 1, gonna just update the data of Round 2 instead of re-generate the orders stuff.
=======
>>>>>>>
// When the node is in Round 1, gonna just update the data of Round 2 instead of re-generate the orders stuff.
<<<<<<<
foreach (var publicKey in term.Miners.PublicKeys)
{
if (index >= Config.Aliases.Count)
return;
var alias = Config.Aliases[index];
_collection.AliasesMap.SetValue(new StringValue {Value = publicKey},
new StringValue {Value = alias});
ConsoleWriteLine(nameof(SetAliases), $"Set alias {alias} to {publicKey}");
index++;
}
}
else
{
foreach (var publicKey in term.Miners.PublicKeys)
{
var alias = publicKey.Substring(0, GlobalConfig.AliasLimit);
_collection.AliasesMap.SetValue(new StringValue {Value = publicKey},
new StringValue {Value = alias});
ConsoleWriteLine(nameof(SetAliases), $"Set alias {alias} to {publicKey}");
}
=======
if (index >= Config.Aliases.Count)
continue;
var alias = Config.Aliases[index];
_collection.AliasesMap.SetValue(new StringValue {Value = publicKey},
new StringValue {Value = alias});
_collection.HistoryMap.SetValue(new StringValue {Value = publicKey},
new CandidateInHistory {CurrentAlias = alias});
index++;
>>>>>>>
foreach (var publicKey in term.Miners.PublicKeys)
{
if (index >= Config.Aliases.Count)
return;
var alias = Config.Aliases[index];
_collection.AliasesMap.SetValue(new StringValue {Value = publicKey},
new StringValue {Value = alias});
_collection.HistoryMap.SetValue(new StringValue {Value = publicKey},
new CandidateInHistory {CurrentAlias = alias});
index++;
}
else
{
foreach (var publicKey in term.Miners.PublicKeys)
{
var alias = publicKey.Substring(0, GlobalConfig.AliasLimit);
_collection.AliasesMap.SetValue(new StringValue {Value = publicKey},
new StringValue {Value = alias});
ConsoleWriteLine(nameof(SetAliases), $"Set alias {alias} to {publicKey}");
}
<<<<<<<
return ticketsMap.OrderByDescending(tm => tm.Value).Take(GlobalConfig.BlockProducerNumber).Select(tm => tm.Key)
=======
return ticketsMap.OrderByDescending(tm => tm.Value).Take(GlobalConfig.BlockProducerNumber)
.Select(tm => tm.Key)
>>>>>>>
return ticketsMap.OrderByDescending(tm => tm.Value).Take(GlobalConfig.BlockProducerNumber)
.Select(tm => tm.Key)
<<<<<<<
/// <summary>
/// Return true if ts1 >= ts2
/// </summary>
/// <param name="ts1"></param>
/// <param name="ts2"></param>
/// <returns></returns>
// ReSharper disable once MemberCanBeMadeStatic.Local
private bool CompareTimestamp(Timestamp ts1, Timestamp ts2)
{
return ts1.ToDateTime() >= ts2.ToDateTime();
}
private bool IsMainchain()
{
return ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId;
}
=======
>>>>>>>
/// <summary>
/// Return true if ts1 >= ts2
/// </summary>
/// <param name="ts1"></param>
/// <param name="ts2"></param>
/// <returns></returns>
// ReSharper disable once MemberCanBeMadeStatic.Local
private bool CompareTimestamp(Timestamp ts1, Timestamp ts2)
{
return ts1.ToDateTime() >= ts2.ToDateTime();
}
private bool IsMainchain()
{
return ChainConfig.Instance.ChainId == GlobalConfig.DefaultChainId;
} |
<<<<<<<
private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
protected IScriptModulePlugin m_ScriptEngine;
protected ISceneChildEntity m_host;
=======
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
protected IScriptModulePlugin m_ScriptEngine;
protected SceneObjectPart m_host;
>>>>>>>
//private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
protected IScriptModulePlugin m_ScriptEngine;
protected ISceneChildEntity m_host;
<<<<<<<
if (linkType < 0 || m_host.ParentEntity == null)
return new List<ISceneChildEntity> ();
IEntity target = m_host.ParentEntity.GetLinkNumPart (linkType);
if (target is ISceneChildEntity)
=======
if (linkType < 0 || m_host.ParentGroup == null)
return new List<SceneObjectPart>();
IEntity target = m_host.ParentGroup.GetLinkNumPart (linkType);
if (target is SceneObjectPart)
>>>>>>>
if (linkType < 0 || m_host.ParentEntity == null)
return new List<ISceneChildEntity> ();
IEntity target = m_host.ParentEntity.GetLinkNumPart (linkType);
if (target is ISceneChildEntity)
<<<<<<<
if (m_host.ParentEntity != null)
{
List<ISceneChildEntity> parts = new List<ISceneChildEntity> (m_host.ParentEntity.ChildrenEntities ());
return parts.ConvertAll<IEntity> (new Converter<ISceneChildEntity, IEntity> (delegate (ISceneChildEntity part)
{
=======
if (m_host.ParentGroup != null)
{
List<SceneObjectPart> parts = new List<SceneObjectPart>(m_host.ParentGroup.ChildrenList);
return parts.ConvertAll<IEntity> (new Converter<SceneObjectPart, IEntity> (delegate (SceneObjectPart part)
{
>>>>>>>
if (m_host.ParentEntity != null)
{
List<ISceneChildEntity> parts = new List<ISceneChildEntity> (m_host.ParentEntity.ChildrenEntities ());
return parts.ConvertAll<IEntity> (new Converter<ISceneChildEntity, IEntity> (delegate (ISceneChildEntity part)
{
<<<<<<<
{
if (m_host.ParentEntity == null)
return new List<IEntity> ();
List<ISceneChildEntity> children = new List<ISceneChildEntity> (m_host.ParentEntity.ChildrenEntities ());
ret = children.ConvertAll<IEntity> (new Converter<ISceneChildEntity, IEntity> (delegate (ISceneChildEntity part)
{
=======
{
if (m_host.ParentGroup == null)
return new List<IEntity> ();
List<SceneObjectPart> children = new List<SceneObjectPart>(m_host.ParentGroup.ChildrenList);
ret = children.ConvertAll<IEntity> (new Converter<SceneObjectPart, IEntity> (delegate (SceneObjectPart part)
{
>>>>>>>
{
if (m_host.ParentEntity == null)
return new List<IEntity> ();
List<ISceneChildEntity> children = new List<ISceneChildEntity> (m_host.ParentEntity.ChildrenEntities ());
ret = children.ConvertAll<IEntity> (new Converter<ISceneChildEntity, IEntity> (delegate (ISceneChildEntity part)
{
<<<<<<<
{
if (linkType < 0 || m_host.ParentEntity == null)
return new List<IEntity> ();
IEntity target = m_host.ParentEntity.GetLinkNumPart (linkType);
if (target == null)
return new List<IEntity> ();
=======
{
if (linkType < 0 || m_host.ParentGroup == null)
return new List<IEntity> ();
IEntity target = m_host.ParentGroup.GetLinkNumPart (linkType);
if (target == null)
return new List<IEntity> ();
>>>>>>>
{
if (linkType < 0 || m_host.ParentEntity == null)
return new List<IEntity> ();
IEntity target = m_host.ParentEntity.GetLinkNumPart (linkType);
if (target == null)
return new List<IEntity> ();
<<<<<<<
if(heightmap != null)
ground = heightmap.GetNormalizedGroundHeight((int)(float)targetPos.x, (int)(float)targetPos.y);
if (part.ParentEntity == null)
=======
if(heightmap != null)
ground = heightmap.GetNormalizedGroundHeight((int)(float)targetPos.x, (int)(float)targetPos.y);
if (part.ParentGroup == null)
>>>>>>>
if(heightmap != null)
ground = heightmap.GetNormalizedGroundHeight((int)(float)targetPos.x, (int)(float)targetPos.y);
if (part.ParentEntity == null)
<<<<<<<
}
else if (linknum == ScriptBaseClass.LINK_SET ||
ScriptBaseClass.LINK_ALL_OTHERS ||
ScriptBaseClass.LINK_ALL_CHILDREN ||
ScriptBaseClass.LINK_THIS)
{
foreach (ISceneChildEntity part in parentPrim.ChildrenEntities())
{
if (part.UUID != m_host.UUID)
{
childPrim = part;
break;
}
}
}
else
{
IEntity target = m_host.ParentEntity.GetLinkNumPart (linknum);
if (target is ISceneChildEntity)
{
childPrim = target as ISceneChildEntity;
}
else
return;
if (childPrim.UUID == m_host.UUID)
childPrim = null;
=======
}
else if (linknum == ScriptBaseClass.LINK_SET ||
ScriptBaseClass.LINK_ALL_OTHERS ||
ScriptBaseClass.LINK_ALL_CHILDREN ||
ScriptBaseClass.LINK_THIS)
{
foreach (SceneObjectPart part in parentPrim.ChildrenList)
{
if (part.UUID != m_host.UUID)
{
childPrim = part;
break;
}
}
}
else
{
IEntity target = m_host.ParentGroup.GetLinkNumPart (linknum);
if (target is SceneObjectPart)
{
childPrim = target as SceneObjectPart;
}
else
return;
if (childPrim.UUID == m_host.UUID)
childPrim = null;
>>>>>>>
}
else if (linknum == ScriptBaseClass.LINK_SET ||
ScriptBaseClass.LINK_ALL_OTHERS ||
ScriptBaseClass.LINK_ALL_CHILDREN ||
ScriptBaseClass.LINK_THIS)
{
foreach (ISceneChildEntity part in parentPrim.ChildrenEntities())
{
if (part.UUID != m_host.UUID)
{
childPrim = part;
break;
}
}
}
else
{
IEntity target = m_host.ParentEntity.GetLinkNumPart (linknum);
if (target is ISceneChildEntity)
{
childPrim = target as ISceneChildEntity;
}
else
return;
if (childPrim.UUID == m_host.UUID)
childPrim = null;
<<<<<<<
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
IEntity target = m_host.ParentEntity.GetLinkNumPart (linknum);
=======
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
IEntity target = m_host.ParentGroup.GetLinkNumPart (linknum);
>>>>>>>
ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
IEntity target = m_host.ParentEntity.GetLinkNumPart (linknum);
<<<<<<<
{
IEntity entity = m_host.ParentEntity.GetLinkNumPart (linknum);
=======
{
IEntity entity = m_host.ParentGroup.GetLinkNumPart (linknum);
>>>>>>>
{
IEntity entity = m_host.ParentEntity.GetLinkNumPart (linknum);
<<<<<<<
}
UserInfo info = m_host.ParentEntity.Scene.RequestModuleInterface<IAgentInfoService> ().GetUserInfo (destId.ToString ());
=======
}
UserInfo info = m_host.ParentGroup.Scene.RequestModuleInterface<IAgentInfoService>().GetUserInfo(destId.ToString());
>>>>>>>
}
UserInfo info = m_host.ParentEntity.Scene.RequestModuleInterface<IAgentInfoService> ().GetUserInfo (destId.ToString ());
<<<<<<<
m_host.ParentEntity.Damage = (float)damage;
}
=======
m_host.ParentGroup.Damage = (float)damage;
}
>>>>>>>
m_host.ParentEntity.Damage = (float)damage;
}
<<<<<<<
}
IAttachmentsModule attachMod = World.RequestModuleInterface<IAttachmentsModule>();
if (attachMod != null)
{
ISceneEntity[] att = attachMod.GetAttachmentsForAvatar (agent.UUID);
if (att.Length > 0)
{
flags |= ScriptBaseClass.AGENT_ATTACHMENTS;
foreach (ISceneEntity gobj in att)
{
if (gobj != null)
{
if (gobj.RootChild.Inventory.ContainsScripts())
{
flags |= ScriptBaseClass.AGENT_SCRIPTED;
break;
}
}
}
}
=======
}
IAttachmentsModule attachMod = World.RequestModuleInterface<IAttachmentsModule>();
if (attachMod != null)
{
SceneObjectGroup[] att = attachMod.GetAttachmentsForAvatar(agent.UUID);
if (att.Length > 0)
{
flags |= ScriptBaseClass.AGENT_ATTACHMENTS;
foreach (SceneObjectGroup gobj in att)
{
if (gobj != null)
{
if (gobj.RootPart.Inventory.ContainsScripts())
{
flags |= ScriptBaseClass.AGENT_SCRIPTED;
break;
}
}
}
}
>>>>>>>
}
IAttachmentsModule attachMod = World.RequestModuleInterface<IAttachmentsModule>();
if (attachMod != null)
{
ISceneEntity[] att = attachMod.GetAttachmentsForAvatar (agent.UUID);
if (att.Length > 0)
{
flags |= ScriptBaseClass.AGENT_ATTACHMENTS;
foreach (ISceneEntity gobj in att)
{
if (gobj != null)
{
if (gobj.RootChild.Inventory.ContainsScripts())
{
flags |= ScriptBaseClass.AGENT_SCRIPTED;
break;
}
}
}
}
<<<<<<<
if (detectedParams == null && !m_host.IsAttachment) return DateTime.Now;
if (detectedParams != null)
avatarID = detectedParams.Key;
IScenePresence avatar = World.GetScenePresence (avatarID);
=======
if (detectedParams == null && !m_host.IsAttachment) return DateTime.Now;
if (detectedParams != null)
avatarID = detectedParams.Key;
ScenePresence avatar = World.GetScenePresence(avatarID);
>>>>>>>
if (detectedParams == null && !m_host.IsAttachment) return DateTime.Now;
if (detectedParams != null)
avatarID = detectedParams.Key;
IScenePresence avatar = World.GetScenePresence (avatarID); |
<<<<<<<
private readonly ConcurrentDictionary<Hash, Transaction> _txs = new ConcurrentDictionary<Hash, Transaction>();
private readonly ConcurrentDictionary<Hash, Transaction> _dPoStxs = new ConcurrentDictionary<Hash, Transaction>();
=======
private readonly ConcurrentDictionary<Hash, ITransaction> _contractTxs = new ConcurrentDictionary<Hash, ITransaction>();
private readonly ConcurrentDictionary<Hash, ITransaction> _dPoSTxs = new ConcurrentDictionary<Hash, ITransaction>();
>>>>>>>
private readonly ConcurrentDictionary<Hash, Transaction> _contractTxs = new ConcurrentDictionary<Hash, Transaction>();
private readonly ConcurrentDictionary<Hash, Transaction> _dPoSTxs = new ConcurrentDictionary<Hash, Transaction>();
<<<<<<<
return await @lock.WriteLock(() =>
=======
return res;
}
/// <summary>
/// enqueue contract tx
/// </summary>
/// <param name="tx"></param>
/// <returns></returns>
private TxValidation.TxInsertionAndBroadcastingError AddContractTransaction(ITransaction tx)
{
if (tx.Type != TransactionType.ContractTransaction)
return TxValidation.TxInsertionAndBroadcastingError.Failed;
if (_contractTxs.ContainsKey(tx.GetHash()))
return TxValidation.TxInsertionAndBroadcastingError.AlreadyInserted;
var res = _contractTxPool.EnQueueTx(tx);
if (res == TxValidation.TxInsertionAndBroadcastingError.Success)
>>>>>>>
return res;
}
/// <summary>
/// enqueue contract tx
/// </summary>
/// <param name="tx"></param>
/// <returns></returns>
private TxValidation.TxInsertionAndBroadcastingError AddContractTransaction(Transaction tx)
{
if (tx.Type != TransactionType.ContractTransaction)
return TxValidation.TxInsertionAndBroadcastingError.Failed;
if (_contractTxs.ContainsKey(tx.GetHash()))
return TxValidation.TxInsertionAndBroadcastingError.AlreadyInserted;
var res = _contractTxPool.EnQueueTx(tx);
if (res == TxValidation.TxInsertionAndBroadcastingError.Success)
<<<<<<<
public async Task<List<Transaction>> GetReadyTxsAsync()
=======
public async Task<List<ITransaction>> GetReadyTxsAsync(double intervals = 150)
>>>>>>>
public async Task<List<Transaction>> GetReadyTxsAsync(double intervals = 150)
<<<<<<<
var tmap = txsOut.Aggregate(new Dictionary<Hash, HashSet<Transaction>>(), (current, p) =>
=======
var tmap = txsOut.Aggregate(new Dictionary<Hash, HashSet<ITransaction>>(), (current, p) =>
>>>>>>>
var tmap = txsOut.Aggregate(new Dictionary<Hash, HashSet<Transaction>>(), (current, p) =>
<<<<<<<
ConcurrentDictionary<Hash, Transaction> transactions;
=======
>>>>>>> |
<<<<<<<
LockWhiteList =
{
Context.GetContractAddressByName(SmartContractConstants.VoteContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.ProfitContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.ElectionContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.TreasuryContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.TokenConverterContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.TokenHolderContractSystemName)
}
=======
IsProfitable = true,
LockWhiteList = {lockWhiteList}
>>>>>>>
LockWhiteList = {lockWhiteList}
<<<<<<<
LockWhiteList =
{
Context.GetContractAddressByName(SmartContractConstants.TreasuryContractSystemName),
Context.GetContractAddressByName(SmartContractConstants.TokenConverterContractSystemName)
},
=======
IsProfitable = true,
LockWhiteList = {lockWhiteList},
>>>>>>>
LockWhiteList = {lockWhiteList}, |
<<<<<<<
=======
using AElf.Kernel.SmartContract;
using AElf.Kernel.SmartContract.Domain;
using AElf.Kernel.SmartContractExecution.Events;
>>>>>>>
<<<<<<<
=======
using Google.Protobuf;
using Google.Protobuf.Collections;
>>>>>>>
using AElf.Kernel.SmartContract.Domain;
using Google.Protobuf.Collections; |
<<<<<<<
ResourceTypes = Enum.GetValues(typeof(ResourceType))
.Cast<ResourceType>().Select(x => x.ToString()).ToList();
=======
ResourceTypes = Enum.GetValues(typeof(UserResourceKey.Types.ResourceType))
.Cast<UserResourceKey.Types.ResourceType>().Select(x => x.ToString().ToUpper()).ToList();
>>>>>>>
ResourceTypes = Enum.GetValues(typeof(ResourceType))
.Cast<ResourceType>().Select(x => x.ToString().ToUpper()).ToList();
<<<<<<<
Type = (ResourceType) Enum.Parse(typeof(ResourceType),
resourceType)
=======
Type = ParseResourceType(resourceType)
>>>>>>>
Type = ParseResourceType(resourceType)
<<<<<<<
Address = Api.GetFromAddress(),
Type = (ResourceType) Enum.Parse(typeof(ResourceType),
resourceType)
=======
Address = Api.GetTransaction().From,
Type = ParseResourceType(resourceType)
>>>>>>>
Address = Api.GetFromAddress(),
Type = ParseResourceType(resourceType)
<<<<<<<
Address = Api.GetFromAddress(),
Type = (ResourceType) Enum.Parse(typeof(ResourceType),
resourceType)
=======
Address = Api.GetTransaction().From,
Type = ParseResourceType(resourceType)
>>>>>>>
Address = Api.GetFromAddress(),
Type = ParseResourceType(resourceType) |
<<<<<<<
typeof(Volo.Abp.AspNetCore.AbpAspNetCoreModule),
typeof(CoreKernelAElfModule),
=======
typeof(AbpAspNetCoreModule),
typeof(KernelAElfModule),
>>>>>>>
typeof(AbpAspNetCoreModule),
typeof(CoreKernelAElfModule), |
<<<<<<<
var networkOptions = context.ServiceProvider.GetService<IOptionsSnapshot<NetworkOptions>>().Value;
if (networkOptions.EnablePeerDiscovery)
{
var peerDiscoveryWorker = context.ServiceProvider.GetService<PeerDiscoveryWorker>();
await peerDiscoveryWorker.StartAsync();
}
=======
taskQueueManager.CreateQueue(OSConsts.InitialSyncQueueName);
>>>>>>>
taskQueueManager.CreateQueue(OSConsts.InitialSyncQueueName);
var networkOptions = context.ServiceProvider.GetService<IOptionsSnapshot<NetworkOptions>>().Value;
if (networkOptions.EnablePeerDiscovery)
{
var peerDiscoveryWorker = context.ServiceProvider.GetService<PeerDiscoveryWorker>();
await peerDiscoveryWorker.StartAsync();
} |
<<<<<<<
sysTxs = FilterDpos(sysTxs);
=======
if (currentRoundInfo != null)
{
// Note that any txn wont be filtered if currentRoundInfo is null.
// It should be better if this parameter can be removed
_txFilter.Execute(sysTxs);
}
>>>>>>>
_txFilter.Execute(sysTxs);
<<<<<<<
traces = await ExecuteTransactions(sysTxs, true);
=======
traces = await ExecuteTransactions(sysTxs);
>>>>>>>
traces = await ExecuteTransactions(sysTxs, true); |
<<<<<<<
using AElf.Kernel.Services;
=======
using AElf.Kernel.TransactionPool.Infrastructure;
>>>>>>>
using AElf.Kernel.Services;
using AElf.Kernel.TransactionPool.Infrastructure;
<<<<<<<
IBlockSynchronizer blockSynchronizer,
IChainService chainService,
IConsensus consensus,
IAccountService accountService,
IConsensusService consensusService)
=======
IAccountService accountService)
>>>>>>>
IBlockSynchronizer blockSynchronizer,
IChainService chainService,
IConsensus consensus,
IAccountService accountService,
IConsensusService consensusService) |
<<<<<<<
using Acs4;
=======
using AElf.Contracts.Consensus.DPoS;
>>>>>>>
using Acs4;
using AElf.Contracts.Consensus.DPoS;
<<<<<<<
=======
using AElf.Kernel.Consensus.AElfConsensus.Application;
>>>>>>>
using AElf.Kernel.Consensus.AElfConsensus.Application;
<<<<<<<
return new DPoSInformationGenerationService(_accountService, _smartContractAddressService,
_transactionReadOnlyExecutionService, information);
=======
return new AElfConsensusInformationGenerationService(_accountService, information, _smartContractAddressService,
_transactionReadOnlyExecutionService);
>>>>>>>
return new AElfConsensusInformationGenerationService(_accountService, information, _smartContractAddressService,
_transactionReadOnlyExecutionService); |
<<<<<<<
new SmartContractService(_smartContractManager, _smartContractRunnerContainer, StateStore,
_functionMetadataService, _chainService), _transactionTraceManager, StateStore,
=======
new SmartContractService(_smartContractManager, _smartContractRunnerContainer, _stateManager,
_functionMetadataService), _transactionTraceManager, _stateManager,
>>>>>>>
new SmartContractService(_smartContractManager, _smartContractRunnerContainer, _stateManager,
_functionMetadataService, _chainService), _transactionTraceManager, _stateManager,
<<<<<<<
StateStore, _functionMetadataService, _chainService), _logger);
=======
_stateManager, _functionMetadataService), _logger);
>>>>>>>
_stateManager, _functionMetadataService, _chainService), _logger); |
<<<<<<<
using AElf.Kernel.Manager.Interfaces;
=======
using AElf.Kernel.Managers;
using AElf.Kernel.Storages;
using AElf.Kernel.Types.Transaction;
>>>>>>>
using AElf.Kernel.Manager.Interfaces;
<<<<<<<
private readonly IChainManager _chainManager;
=======
>>>>>>>
private readonly IChainManager _chainManager;
<<<<<<<
IMerkleTreeManager merkleTreeManager, ServerManager serverManager,
IBlockValidationService blockValidationService, IChainContextService chainContextService
, IChainManager chainManager,IStateManager stateManager)
=======
IBinaryMerkleTreeManager binaryMerkleTreeManager, ServerManager serverManager,IBlockValidationService blockValidationService, IChainContextService chainContextService
,IStateStore stateStore)
>>>>>>>
IMerkleTreeManager merkleTreeManager, ServerManager serverManager,
IBlockValidationService blockValidationService, IChainContextService chainContextService
, IChainManager chainManager,IStateManager stateManager)
<<<<<<<
_clientManager = clientManager;
_merkleTreeManager = merkleTreeManager;
_serverManager = serverManager;
=======
_binaryMerkleTreeManager = binaryMerkleTreeManager;
>>>>>>>
_merkleTreeManager = merkleTreeManager;
<<<<<<<
if (block.Body.IndexedInfo.Count > 0)
_merkleTreeManager.AddSideChainTransactionRootsMerkleTreeAsync(
block.Body.BinaryMerkleTreeForSideChainTransactionRoots, Config.ChainId, block.Header.Index);
=======
>>>>>>> |
<<<<<<<
GetGenesisSmartContractDtosForReferendum(),
GetGenesisSmartContractDtosForAssociation(),
GetGenesisSmartContractDtosForTokenHolder(),
=======
>>>>>>>
GetGenesisSmartContractDtosForTokenHolder(), |
<<<<<<<
private readonly IBlockValidationService _blockValidationService;
private readonly IChainContextService _chainContextService;
public MockSetup(ILogger logger, IDataStore dataStore, IBlockValidationService blockValidationService, IChainContextService chainContextService)
=======
private readonly IStateStore _stateStore;
private TxHub _txHub;
public MockSetup(ILogger logger, IDataStore dataStore, IStateStore stateStore)
>>>>>>>
private readonly IStateStore _stateStore;
private TxHub _txHub;
private readonly IBlockValidationService _blockValidationService;
private readonly IChainContextService _chainContextService;
public MockSetup(ILogger logger, IDataStore dataStore, IStateStore stateStore, IBlockValidationService blockValidationService, IChainContextService chainContextService)
<<<<<<<
_blockValidationService = blockValidationService;
_chainContextService = chainContextService;
=======
_stateStore = stateStore;
>>>>>>>
_blockValidationService = blockValidationService;
_chainContextService = chainContextService;
_stateStore = stateStore;
<<<<<<<
_chainService = new ChainService(new ChainManagerBasic(_dataStore),
new BlockManagerBasic(_dataStore),
_transactionManager, _dataStore, new BlockSet());
=======
_chainService = new ChainService(new ChainManagerBasic(_dataStore), new BlockManagerBasic(_dataStore, _logger),
_transactionManager, _dataStore);
>>>>>>>
_chainService = new ChainService(new ChainManagerBasic(_dataStore), new BlockManagerBasic(_dataStore),
_transactionManager, _dataStore);
_chainService = new ChainService(new ChainManagerBasic(_dataStore),
new BlockManagerBasic(_dataStore),
_transactionManager, _dataStore);
<<<<<<<
var miner = new AElf.Miner.Miner.Miner(config, poolService, _chainService, _stateDictator,
_concurrencyExecutingService, _transactionManager, _transactionResultManager, _logger,
clientManager, _binaryMerkleTreeManager, null, _blockValidationService, _chainContextService);
=======
var miner = new AElf.Miner.Miner.Miner(config, pool, _chainService, _concurrencyExecutingService,
_transactionManager, _transactionResultManager, _logger, clientManager, _binaryMerkleTreeManager, null);
>>>>>>>
var miner = new AElf.Miner.Miner.Miner(config, pool, _chainService, _concurrencyExecutingService,
_transactionManager, _transactionResultManager, _logger, clientManager, _binaryMerkleTreeManager, null, _blockValidationService, _chainContextService); |
<<<<<<<
public const int TimeForNetwork = 100;
public const long MiningRewardPerBlock = 12500000;
public const int MinMinersCount = 9;
public const int RandomNumberRequestMinersCount = 5;
public const int RandomNumberDueRoundCount = 5;
=======
public const int MinimumIntervalOfProducingBlocks = 100;
public const long InitialMiningRewardPerBlock = 12500000;
public const long TimeToReduceMiningRewardByHalf = 126144000;// 60 * 60 * 24 * 365 * 4
public const int InitialMinersCount = 9;
public const int KeepRounds = 32;
>>>>>>>
public const int TimeForNetwork = 100;
public const long MiningRewardPerBlock = 12500000;
public const int MinMinersCount = 9;
public const int RandomNumberRequestMinersCount = 5;
public const int RandomNumberDueRoundCount = 5;
public const int MinimumIntervalOfProducingBlocks = 100;
public const long InitialMiningRewardPerBlock = 12500000;
public const long TimeToReduceMiningRewardByHalf = 126144000;// 60 * 60 * 24 * 365 * 4
public const int InitialMinersCount = 9;
public const int KeepRounds = 32; |
<<<<<<<
using AElf.Execution.Execution;
using AElf.Miner.EventMessages;
using AElf.Miner.TxMemPool;
=======
using Org.BouncyCastle.Asn1.X9;
using AElf.Miner.Rpc.Exceptions;
>>>>>>>
using AElf.Configuration;
using AElf.Cryptography.ECDSA;
using AElf.Kernel;
using AElf.Kernel.Managers;
using AElf.Miner.Rpc.Exceptions;
using AElf.Miner.Rpc.Server;
using AElf.SmartContract;
using AElf.Types.CSharp;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using Easy.MessageHub;
using NLog;
using NServiceKit.Common.Extensions;
using Status = AElf.Kernel.Status;
using AElf.Execution.Execution;
using AElf.Miner.EventMessages;
using AElf.Miner.TxMemPool;
<<<<<<<
public Miner(IMinerConfig config, ITxPool txPool, IChainService chainService,
IStateDictator stateDictator, IExecutingService executingService, ITransactionManager transactionManager,
=======
public Miner(IMinerConfig config, ITxPoolService txPoolService, IChainService chainService,
IExecutingService executingService, ITransactionManager transactionManager,
>>>>>>>
public Miner(IMinerConfig config, ITxPool txPool, IChainService chainService,
IExecutingService executingService, ITransactionManager transactionManager,
<<<<<<<
var genTx = await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPool.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 genTx = await GenerateTransactionWithParentChainBlockInfo(parentChainBlockInfo);
var readyTxs = await _txPool.GetReadyTxsAsync(currentRoundInfo);
// 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()}");
} |
<<<<<<<
int chainId = ChainHelpers.GetChainId(serialNumber);
=======
int chainId = ChainHelper.GetChainId(serialNumber);
var info = State.SideChainInfos[chainId];
Assert(info == null, "Chain creation request already exists.");
>>>>>>>
int chainId = ChainHelper.GetChainId(serialNumber); |
<<<<<<<
=======
//private bool testRealGravity;
>>>>>>>
private bool testRealGravity;
private int throttleCounter; |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.