public async Task <ByteString> PrepareExtraDataForNextMiningAsync(Hash blockHash, long blockHeight)
{
if (!_transactionPackingOptions.IsTransactionPackable)
{
return(ByteString.Empty);
}
var utcNow = TimestampHelper.GetUtcNow();
var pendingProposal = await GetPendingCrossChainIndexingProposalAsync(blockHash, blockHeight, utcNow);
if (pendingProposal == null || pendingProposal.ExpiredTime.AddMilliseconds(500) <= utcNow)
{
// propose new cross chain indexing data if pending proposal is null or expired
var crossChainBlockData = await GetCrossChainBlockDataForNextMining(blockHash, blockHeight);
if (!crossChainBlockData.IsNullOrEmpty())
{
_transactionInputForBlockMiningDataProvider.AddTransactionInputForBlockMining(blockHash,
new CrossChainTransactionInput
{
PreviousBlockHeight = blockHeight,
MethodName =
nameof(CrossChainContractContainer.CrossChainContractStub.ProposeCrossChainIndexing),
Value = crossChainBlockData.ToByteString()
});
}
return(ByteString.Empty);
}
if (!pendingProposal.ToBeReleased)
{
return(ByteString.Empty); // do nothing if pending proposal is not ready to be released
}
// release pending proposal and unable to propose anything if it is ready
_transactionInputForBlockMiningDataProvider.AddTransactionInputForBlockMining(blockHash,
new CrossChainTransactionInput
{
PreviousBlockHeight = blockHeight,
MethodName =
nameof(CrossChainContractContainer.CrossChainContractStub.ReleaseCrossChainIndexing),
Value = pendingProposal.ProposalId.ToByteString()
});
return(ExtractCrossChainExtraDataFromCrossChainBlockData(pendingProposal.ProposedCrossChainBlockData));
}
public async Task AttachBlockAsync_Test()
{
var chain = await _smartContractExecutionHelper.CreateChainAsync();
await _blockAttachService.AttachBlockAsync(_kernelTestHelper.GenerateBlock(0, Hash.Empty));
var blockHeader = new BlockHeader
{
Height = chain.BestChainHeight + 1,
PreviousBlockHash = chain.BestChainHash,
Time = TimestampHelper.GetUtcNow(),
SignerPubkey = ByteString.CopyFrom(CryptoHelper.GenerateKeyPair().PublicKey)
};
var transactions = new List <Transaction>
{
new Transaction
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(ACS0Container.ACS0Stub.DeploySmartContract),
Params = new ContractDeploymentInput
{
Category = KernelConstants.DefaultRunnerCategory,
Code = ByteString.CopyFrom(
_smartContractExecutionHelper.ContractCodes["AElf.Contracts.MultiToken"])
}.ToByteString()
}
};
var blockExecutedSet = await _blockExecutingService.ExecuteBlockAsync(blockHeader, transactions);
await _blockchainService.AddBlockAsync(blockExecutedSet.Block);
_blockAttachService.AttachBlockAsync(blockExecutedSet.Block).ShouldThrow <Exception>();
await _blockchainService.AddTransactionsAsync(transactions);
await _blockAttachService.AttachBlockAsync(blockExecutedSet.Block);
var newChain = await _blockchainService.GetChainAsync();
newChain.BestChainHeight.ShouldBe(chain.BestChainHeight + 1);
}
public async Task Disposal_SideChain_NotAuthorized()
{
long lockedTokenAmount = 10;
await InitializeCrossChainContractAsync();
await ApproveBalanceAsync(lockedTokenAmount);
var chainId = await InitAndCreateSideChainAsync();
var disposalInput = new SInt32Value
{
Value = chainId
};
var ecKeyPair = CryptoHelper.GenerateKeyPair();
var other = Tester.CreateNewContractTester(ecKeyPair);
var organizationAddress = Address.Parser.ParseFrom((await Tester.ExecuteContractWithMiningAsync(
ParliamentAddress,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.GetGenesisOwnerAddress),
new Empty()))
.ReturnValue);
var proposal = await other.ExecuteContractWithMiningAsync(ParliamentAddress,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.CreateProposal),
new CreateProposalInput
{
ContractMethodName = "DisposeSideChain",
ExpiredTime = TimestampHelper.GetUtcNow().AddDays(1),
Params = disposalInput.ToByteString(),
ToAddress = CrossChainContractAddress,
OrganizationAddress = organizationAddress
});
var proposalId = Hash.Parser.ParseFrom(proposal.ReturnValue);
await ApproveWithMinersAsync(proposalId);
var transactionResult = await other.ExecuteContractWithMiningAsync(ParliamentAddress,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Release), proposalId);
var status = transactionResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.Contains("Not authorized to dispose.", transactionResult.Error);
}
private async Task DeployContractsAsync()
{
var category = KernelConstants.CodeCoverageRunnerCategory;
var code = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("Configuration")).Value;
OptionalLogEventListeningService <IBlockAcceptedLogEventHandler> .Enabled = true;
ConfigurationContractAddress = await DeploySystemSmartContract(category, code,
ConfigurationSmartContractAddressNameProvider.Name, DefaultSenderKeyPair);
_configurationStub =
GetTester <ConfigurationContainer.ConfigurationStub>(ConfigurationContractAddress,
DefaultSenderKeyPair);
var consensusContractCode = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("Consensus.AEDPoS")).Value;
var consensusContractAddress = await DeploySystemSmartContract(category, consensusContractCode,
ConsensusSmartContractAddressNameProvider.Name, DefaultSenderKeyPair);
var consensusStub = GetTester <AEDPoSContractImplContainer.AEDPoSContractImplStub>(consensusContractAddress,
DefaultSenderKeyPair);
await consensusStub.FirstRound.SendAsync(
new MinerList
{
Pubkeys = { ByteString.CopyFrom(DefaultSenderKeyPair.PublicKey) }
}.GenerateFirstRoundOfNewTerm(4000, TimestampHelper.GetUtcNow())
);
var parliamentContractCode = Codes.Single(kv => kv.Key.Split(",").First().EndsWith("Parliament")).Value;
var parliamentContractAddress = await DeploySystemSmartContract(category, parliamentContractCode,
ParliamentSmartContractAddressNameProvider.Name, DefaultSenderKeyPair);
_parliamentContractStub = GetTester <ParliamentContractContainer.ParliamentContractStub>(parliamentContractAddress,
DefaultSenderKeyPair);
await _parliamentContractStub.Initialize.SendAsync(new InitializeInput
{
ProposerAuthorityRequired = true,
PrivilegedProposer = Address.FromPublicKey(DefaultSenderKeyPair.PublicKey)
});
var chain = await _blockchainService.GetChainAsync();
await _blockchainService.SetIrreversibleBlockAsync(chain, chain.BestChainHeight, chain.BestChainHash);
}
public async Task RequestMining_Test()
{
var chain = await _blockchainService.GetChainAsync();
var request = new ConsensusRequestMiningDto
{
BlockTime = TimestampHelper.GetUtcNow(),
BlockExecutionTime = TimestampHelper.DurationFromMilliseconds(500),
MiningDueTime = TimestampHelper.GetUtcNow().AddMilliseconds(499),
PreviousBlockHash = chain.BestChainHash,
PreviousBlockHeight = chain.BestChainHeight
};
var block = await _miningRequestService.RequestMiningAsync(request);
block.ShouldBeNull();
request = new ConsensusRequestMiningDto
{
BlockTime = TimestampHelper.GetUtcNow().AddMilliseconds(-501),
BlockExecutionTime = TimestampHelper.DurationFromMilliseconds(500),
MiningDueTime = TimestampHelper.GetUtcNow().AddMilliseconds(350),
PreviousBlockHash = chain.BestChainHash,
PreviousBlockHeight = chain.BestChainHeight
};
block = await _miningRequestService.RequestMiningAsync(request);
block.ShouldBeNull();
request = new ConsensusRequestMiningDto
{
BlockTime = TimestampHelper.GetUtcNow().AddMilliseconds(-400),
BlockExecutionTime = TimestampHelper.DurationFromMilliseconds(500),
MiningDueTime = TimestampHelper.GetUtcNow().AddMilliseconds(350),
PreviousBlockHash = chain.BestChainHash,
PreviousBlockHeight = chain.BestChainHeight
};
block = await _miningRequestService.RequestMiningAsync(request);
block.ShouldNotBeNull();
block.Header.PreviousBlockHash.ShouldBe(chain.BestChainHash);
block.Header.Height.ShouldBe(chain.BestChainHeight + 1);
block.Header.Time.ShouldBe(request.BlockTime);
}
public async Task DAOManagementTest_Join()
{
await InitialDAOContract();
// Alice want to join DAO.
// First approve.
var balanceBefore = (await AliceTokenContractStub.GetBalance.CallAsync(new GetBalanceInput
{
Owner = AliceAddress,
Symbol = "ELF"
})).Balance;
await AliceTokenContractStub.Approve.SendAsync(new ApproveInput
{
Spender = DAOContractAddress,
Symbol = "ELF",
Amount = DepositAmount
});
var proposalId = (await AliceParliamentStub.CreateProposal.SendAsync(new CreateProposalInput
{
OrganizationAddress = ParliamentDefaultOrganizationAddress,
ContractMethodName = nameof(DAOContractStub.ProposeJoin),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1),
Params = AliceAddress.ToByteString(),
ToAddress = DAOContractAddress
})).Output;
await ParliamentApproveAsync(proposalId);
await AliceParliamentStub.Release.SendAsync(proposalId);
// Check DAO member list.
var memberList = (await DAOContractStub.GetDAOMemberList.CallAsync(new Empty())).Value;
memberList.ShouldContain(AliceAddress);
var balanceAfter = (await AliceTokenContractStub.GetBalance.CallAsync(new GetBalanceInput
{
Owner = AliceAddress,
Symbol = "ELF"
})).Balance;
(balanceBefore - balanceAfter).ShouldBe(DepositAmount);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var services = context.Services;
services.AddTransient <IBlockValidationService>(p =>
{
var mockProvider = new Mock <IBlockValidationService>();
mockProvider.Setup(m => m.ValidateBlockAfterExecuteAsync(It.IsAny <IBlock>()))
.ReturnsAsync(true);
return(mockProvider.Object);
});
services.AddTransient <IBlockExecutingService>(p =>
{
var mockService = new Mock <IBlockExecutingService>();
mockService.Setup(m =>
m.ExecuteBlockAsync(It.IsAny <BlockHeader>(), It.IsAny <IEnumerable <Transaction> >()))
.Returns <BlockHeader, IEnumerable <Transaction> >((blockHeader, transactions) =>
{
Block result;
if (blockHeader.Height == Constants.GenesisBlockHeight)
{
result = new Block {
Header = blockHeader
};
}
else
{
result = new Block
{
Header = new BlockHeader {
Time = TimestampHelper.GetUtcNow()
}
};
}
return(Task.FromResult(result));
});
return(mockService.Object);
});
}
private GrpcPeer CreateNewPeer()
{
var pubkey = "048f5ced21f8d687cb9ade1c22dc0e183b05f87124c82073f5d82a09b139cc466efbfb6f28494d0a9d7366fcb769fe5436cfb7b5d322a2b0f69c4bcb1c33ac24ad";
var ipAddress = "127.0.0.1:888";
AElfPeerEndpointHelper.TryParse(ipAddress, out var remoteEndpoint);
var channel = new Channel(ipAddress, ChannelCredentials.Insecure);
var client = new PeerService.PeerServiceClient(channel);
var connectionInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
return(new GrpcPeer(new GrpcClient(channel, client), remoteEndpoint, connectionInfo));
}
public async Task <GrpcPeer> DialBackPeerAsync(DnsEndPoint remoteEndpoint, Handshake handshake)
{
var client = CreateClient(remoteEndpoint);
await PingNodeAsync(client, remoteEndpoint);
var peer = new GrpcPeer(client, remoteEndpoint, new PeerConnectionInfo
{
Pubkey = handshake.HandshakeData.Pubkey.ToHex(),
ConnectionTime = TimestampHelper.GetUtcNow(),
SessionId = handshake.SessionId.ToByteArray(),
ProtocolVersion = handshake.HandshakeData.Version,
IsInbound = true
});
peer.UpdateLastReceivedHandshake(handshake);
return(peer);
}
private bool ValidateBlockMiningTime(Timestamp blockTime, Timestamp miningDueTime,
Duration blockExecutionDuration)
{
if (miningDueTime - Duration.FromTimeSpan(TimeSpan.FromMilliseconds(250)) <
blockTime + blockExecutionDuration)
{
Logger.LogDebug(
$"Mining canceled because mining time slot expired. MiningDueTime: {miningDueTime}, BlockTime: {blockTime}, Duration: {blockExecutionDuration}");
return(false);
}
if (blockTime + blockExecutionDuration >= TimestampHelper.GetUtcNow())
{
return(true);
}
Logger.LogDebug($"Will cancel mining due to timeout: Actual mining time: {blockTime}, " +
$"execution limit: {blockExecutionDuration.Milliseconds()} ms.");
return(false);
}
public async Task PrepareExtraDataForNextMiningAsync_AlmostExpired_NotApproved_Test()
{
var sideChainId = 123;
var sideChainBlockInfoCache = new List <SideChainBlockData>();
var cachingCount = 5;
for (int i = 0; i < cachingCount + CrossChainConstants.DefaultBlockCacheEntityCount; i++)
{
sideChainBlockInfoCache.Add(new SideChainBlockData()
{
ChainId = sideChainId,
Height = (i + 1),
TransactionStatusMerkleTreeRoot = Hash.FromString((sideChainId + 1).ToString())
});
}
_crossChainTestHelper.AddFakeSideChainIdHeight(sideChainId, 1);
var fakeCache = new Dictionary <int, List <IBlockCacheEntity> >
{
{ sideChainId, sideChainBlockInfoCache.ToList <IBlockCacheEntity>() }
};
AddFakeCacheData(fakeCache);
var crossChainBlockData = new CrossChainBlockData
{
SideChainBlockDataList = { sideChainBlockInfoCache }
};
_crossChainTestHelper.AddFakePendingCrossChainIndexingProposal(
new GetPendingCrossChainIndexingProposalOutput
{
Proposer = SampleAddress.AddressList[0],
ProposalId = Hash.FromString("ProposalId"),
ProposedCrossChainBlockData = crossChainBlockData,
ToBeReleased = false,
ExpiredTime = TimestampHelper.GetUtcNow().AddMilliseconds(500)
});
var res = await _crossChainIndexingDataService.PrepareExtraDataForNextMiningAsync(Hash.Empty, 1);
Assert.Empty(res);
}
/// <summary>
/// Given an IP address, will create a handshake to the distant node for
/// further communications.
/// </summary>
/// <returns>The created peer</returns>
public async Task <GrpcPeer> DialPeerAsync(DnsEndPoint remoteEndpoint)
{
var client = await CreateClientAsync(remoteEndpoint);
var handshake = await _handshakeProvider.GetHandshakeAsync();
var handshakeReply = await CallDoHandshakeAsync(client, remoteEndpoint, handshake);
// verify handshake
if (handshakeReply.Error != HandshakeError.HandshakeOk)
{
Logger.LogWarning($"Handshake error: {remoteEndpoint} {handshakeReply.Error}.");
await client.Channel.ShutdownAsync();
return(null);
}
if (await _handshakeProvider.ValidateHandshakeAsync(handshakeReply.Handshake) !=
HandshakeValidationResult.Ok)
{
Logger.LogWarning($"Connect error: {remoteEndpoint} {handshakeReply}.");
await client.Channel.ShutdownAsync();
return(null);
}
var peer = new GrpcPeer(client, remoteEndpoint, new PeerConnectionInfo
{
Pubkey = handshakeReply.Handshake.HandshakeData.Pubkey.ToHex(),
ConnectionTime = TimestampHelper.GetUtcNow(),
ProtocolVersion = handshakeReply.Handshake.HandshakeData.Version,
SessionId = handshakeReply.Handshake.SessionId.ToByteArray(),
IsInbound = false,
IsSecure = client.IsSecure
});
peer.UpdateLastReceivedHandshake(handshakeReply.Handshake);
peer.InboundSessionId = handshake.SessionId.ToByteArray();
peer.UpdateLastSentHandshake(handshake);
return(peer);
}
public void Enqueue(Func <Task> task, string queueName)
{
var enqueueTime = TimestampHelper.GetUtcNow();
_taskQueueManager.Enqueue(async() =>
{
try
{
Logger.LogTrace($"Execute block sync job: {queueName}, enqueue time: {enqueueTime}");
_blockSyncStateProvider.SetEnqueueTime(queueName, enqueueTime);
await task();
}
finally
{
_blockSyncStateProvider.SetEnqueueTime(queueName, null);
}
}, queueName);
}
public async Task <Block> MinedOneBlock(Hash previousBlockHash = null, long previousBlockHeight = 0)
{
if (previousBlockHash == null || previousBlockHeight == 0)
{
var chain = await _blockchainService.GetChainAsync();
previousBlockHash = chain.BestChainHash;
previousBlockHeight = chain.BestChainHeight;
}
var block = await _minerService.MineAsync(previousBlockHash, previousBlockHeight,
TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromMilliseconds(4000));
await _blockchainService.AddBlockAsync(block);
await _blockAttachService.AttachBlockAsync(block);
return(block);
}
GenerateConsensusInitializationCallList()
{
var consensusContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusContractCallList.Add(nameof(AEDPoSContractStub.InitialAElfConsensusContract),
new InitialAElfConsensusContractInput
{
PeriodSeconds = 604800L,
MinerIncreaseInterval = 31536000,
IsSideChain = true
});
consensusContractCallList.Add(nameof(AEDPoSContractStub.FirstRound), new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
}.GenerateFirstRoundOfNewTerm(4000, TimestampHelper.GetUtcNow()));
return(consensusContractCallList);
}
private async Task <SmartContractRegistration> GetSmartContractRegistrationFromZeroAsync(
IExecutive executiveZero, IChainContext chainContext, Hash codeHash)
{
var transaction = new Transaction()
{
From = FromAddress,
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "GetSmartContractRegistration",
Params = codeHash.ToByteString()
};
var trace = new TransactionTrace
{
TransactionId = transaction.GetHash()
};
var txCtxt = new TransactionContext
{
PreviousBlockHash = chainContext.BlockHash,
CurrentBlockTime = TimestampHelper.GetUtcNow(),
Transaction = transaction,
BlockHeight = chainContext.BlockHeight + 1,
Trace = trace,
CallDepth = 0,
StateCache = chainContext.StateCache
};
await executiveZero.ApplyAsync(txCtxt);
var returnBytes = txCtxt.Trace?.ReturnValue;
if (returnBytes != null && returnBytes != ByteString.Empty)
{
return(SmartContractRegistration.Parser.ParseFrom(returnBytes));
}
if (!txCtxt.Trace.IsSuccessful())
{
throw new SmartContractFindRegistrationException(
$"failed to find registration from zero contract {txCtxt.Trace.Error}");
}
return(null);
}
public void CleanIdleExecutive()
{
var executivePools = _smartContractExecutiveProvider.GetExecutivePools();
foreach (var executivePool in executivePools)
{
foreach (var executiveBag in executivePool.Value.Values)
{
if (executiveBag.Count > ExecutiveClearLimit && executiveBag.Min(o => o.LastUsedTime) <
TimestampHelper.GetUtcNow() - TimestampHelper.DurationFromSeconds(ExecutiveExpirationTime))
{
if (executiveBag.TryTake(out _))
{
Logger.LogDebug($"Cleaned an idle executive for address {executivePool.Key}.");
}
}
}
}
}
private async Task <Hash> CreateFeeProposalAsync(Address contractAddress, Address organizationAddress,
string methodName, IMessage input)
{
var parliamentContractStub = GetParliamentContractTester(InitialMinersKeyPairs[0]);
var proposal = new CreateProposalInput
{
OrganizationAddress = organizationAddress,
ContractMethodName = methodName,
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1),
Params = input.ToByteString(),
ToAddress = contractAddress
};
var createResult = await parliamentContractStub.CreateProposal.SendAsync(proposal);
var proposalId = createResult.Output;
return(proposalId);
}
private async Task UpdateSmartContractAddressesAsync(BlockHeader blockHeader,
ISmartContractAddressNameProvider smartContractAddressNameProvider)
{
var transaction = new Transaction()
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(Acs0.ACS0Container.ACS0Stub.GetContractAddressByName),
Params = smartContractAddressNameProvider.ContractName.ToByteString()
};
var address = await _transactionExecutingService.ExecuteAsync <Address>(
new ChainContext { BlockHash = blockHeader.GetHash(), BlockHeight = blockHeader.Height }, transaction,
TimestampHelper.GetUtcNow(), true);
if (!address.Value.IsEmpty)
{
_smartContractAddressService.SetAddress(smartContractAddressNameProvider.ContractName, address);
}
}
private async Task <TResp> RequestAsync <TResp>(Func <AsyncUnaryCall <TResp> > func, GrpcRequest requestParams)
{
var metricsName = requestParams.MetricName;
var timeRequest = !string.IsNullOrEmpty(metricsName);
var requestStartTime = TimestampHelper.GetUtcNow();
Stopwatch requestTimer = null;
if (timeRequest)
{
requestTimer = Stopwatch.StartNew();
}
try
{
var response = await func();
if (timeRequest)
{
requestTimer.Stop();
RecordMetric(requestParams, requestStartTime, requestTimer.ElapsedMilliseconds);
}
return(response);
}
catch (ObjectDisposedException ex)
{
throw new NetworkException("Peer is closed", ex, NetworkExceptionType.Unrecoverable);
}
catch (AggregateException ex)
{
throw HandleRpcException(ex.InnerException as RpcException, requestParams.ErrorMessage);
}
finally
{
if (timeRequest)
{
requestTimer.Stop();
RecordMetric(requestParams, requestStartTime, requestTimer.ElapsedMilliseconds);
}
}
}
public async Task SetControllerForManageConnector_Test()
{
var createOrganizationResult = await ParliamentContractStub.CreateOrganization.SendAsync(
new CreateOrganizationInput
{
ProposalReleaseThreshold = new ProposalReleaseThreshold
{
MinimalApprovalThreshold = 1000,
MinimalVoteThreshold = 1000
}
});
var organizationAddress = createOrganizationResult.Output;
var defaultController =
await TokenConverterContractStub.GetControllerForManageConnector.CallAsync(new Empty());
var defaultOrganization = await ParliamentContractStub.GetDefaultOrganizationAddress.CallAsync(new Empty());
var proposal = await ParliamentContractStub.CreateProposal.SendAsync(new CreateProposalInput
{
ToAddress = TokenConverterContractAddress,
ContractMethodName = nameof(TokenConverterContractStub.ChangeConnectorController),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1),
Params = new AuthorityInfo
{
ContractAddress = defaultController.ContractAddress,
OwnerAddress = organizationAddress
}.ToByteString(),
OrganizationAddress = defaultOrganization
});
var proposalId = proposal.Output;
await ApproveWithAllMinersAsync(proposalId);
var releaseResult = await ParliamentContractStub.Release.SendAsync(proposalId);
releaseResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
var newController = await TokenConverterContractStub.GetControllerForManageConnector.CallAsync(new Empty());
newController.OwnerAddress.ShouldBe(organizationAddress);
}
public async Task Basic_Mapped1Type_Test()
{
var from = SampleAddress.AddressList[0].GetFormatted();
var pairA = "ELF";
var to = SampleAddress.AddressList[1].GetFormatted();
var pairB = "USDT";
await TestBasicSecurityContractStub.TestMapped2State.SendAsync(new Complex3Input
{
From = from,
PairA = pairA,
To = to,
PairB = pairB,
TradeDetails = new TradeMessage
{
FromAmount = 1830,
ToAmount = 1000,
Timestamp = TimestampHelper.GetUtcNow()
}
});
var queryResult = (await TestBasicSecurityContractStub.QueryMappedState2.CallAsync(new Complex3Input
{
From = from,
PairA = pairA,
To = to,
PairB = pairB
}));
queryResult.FromAmount.ShouldBe(1830);
queryResult.ToAmount.ShouldBe(1000);
queryResult = (await TestBasicSecurityContractStub.QueryMappedState2.CallAsync(new Complex3Input
{
From = from,
PairA = pairA,
To = to,
PairB = "ETH"
}));
queryResult.FromAmount.ShouldBe(0);
queryResult.ToAmount.ShouldBe(0);
}
public async Task <bool> ValidateBeforeAttachAsync(IBlock block)
{
if (block?.Header == null || block.Body == null)
{
Logger.LogWarning($"Block header or body is null.");
return(false);
}
if (block.Body.TransactionsCount == 0)
{
Logger.LogWarning($"Block transactions is empty");
return(false);
}
if (_blockchainService.GetChainId() != block.Header.ChainId)
{
Logger.LogWarning($"Block chain id mismatch {block.Header.ChainId}");
return(false);
}
if (block.Header.Height != Constants.GenesisBlockHeight && !block.VerifySignature())
{
Logger.LogWarning($"Block verify signature failed.");
return(false);
}
if (block.Body.CalculateMerkleTreeRoot() != block.Header.MerkleTreeRootOfTransactions)
{
Logger.LogWarning($"Block merkle tree root mismatch.");
return(false);
}
if (block.Header.Height != Constants.GenesisBlockHeight &&
block.Header.Time.ToDateTime() - TimestampHelper.GetUtcNow().ToDateTime() >
KernelConstants.AllowedFutureBlockTimeSpan.ToTimeSpan())
{
Logger.LogWarning($"Future block received {block}, {block.Header.Time.ToDateTime()}");
return(false);
}
return(true);
}
public bool SchedulePeerForReconnection(string endpoint)
{
var nextTry = TimestampHelper.GetUtcNow().AddMilliseconds(NetworkOptions.PeerReconnectionPeriod);
Logger.LogDebug($"Scheduling {endpoint} for reconnection at {nextTry}.");
var reconnectingPeer = new ReconnectingPeer {
Endpoint = endpoint,
NextAttempt = nextTry,
DisconnectionTime = TimestampHelper.GetUtcNow()
};
if (!_reconnectionStateProvider.AddReconnectingPeer(endpoint, reconnectingPeer))
{
Logger.LogWarning($"Reconnection scheduling failed to {endpoint}.");
return(false);
}
return(true);
}
private async Task InitializeAElfConsensus()
{
{
await AEDPoSContractStub.InitialAElfConsensusContract.SendAsync(
new InitialAElfConsensusContractInput
{
PeriodSeconds = 604800L,
MinerIncreaseInterval = 31536000
});
}
{
await AEDPoSContractStub.FirstRound.SendAsync(
GenerateFirstRoundOfNewTerm(
new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
},
4000, TimestampHelper.GetUtcNow()));
}
}
private static IPeer CreatePeer(string ipEndpoint = NetworkTestConstants.FakeIpEndpoint, string pubKey = null)
{
var peerMock = new Mock <IPeer>();
var pubkey = pubKey ?? CryptoHelper.GenerateKeyPair().PublicKey.ToHex();
var peerInfo = new PeerConnectionInfo
{
Pubkey = pubkey,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
var endpoint = ParseEndPoint(ipEndpoint);
peerMock.Setup(p => p.RemoteEndpoint).Returns(endpoint);
peerMock.Setup(p => p.Info).Returns(peerInfo);
return(peerMock.Object);
}
public async Task VoteContract_Register_CurrencyNotSupportVoting_Test()
{
var startTime = TimestampHelper.GetUtcNow();
var input = new VotingRegisterInput
{
TotalSnapshotNumber = 5,
EndTimestamp = startTime.AddDays(100),
StartTimestamp = startTime,
Options =
{
GenerateOptions(3)
},
AcceptedCurrency = "USDT",
IsLockToken = true
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Claimed accepted token is not available for voting").ShouldBeTrue();
}
public async Task MineWithTxHubAsync()
{
var txCount = 0;
var preBlockHash = _chain.BestChainHash;
var preBlockHeight = _chain.BestChainHeight;
while (txCount < TransactionCount)
{
var blockExecutedSet = await _minerService.MineAsync(preBlockHash, preBlockHeight,
TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromMilliseconds(4000));
txCount += blockExecutedSet.TransactionIds.Count();
_transactionIdList.AddRange(blockExecutedSet.TransactionIds.ToList());
await BlockchainService.SetBestChainAsync(_chain, preBlockHeight, preBlockHash);
await TransactionPoolService.CleanByTransactionIdsAsync(blockExecutedSet.TransactionIds);
await TransactionPoolService.UpdateTransactionPoolByBestChainAsync(preBlockHash, preBlockHeight);
}
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
var pool = context.ServiceProvider.GetRequiredService <IPeerPool>();
var channel = new Channel(NetworkTestConstants.FakeIpEndpoint, ChannelCredentials.Insecure);
var connectionInfo = new PeerConnectionInfo
{
Pubkey = NetworkTestConstants.FakePubkey2,
ProtocolVersion = KernelConstants.ProtocolVersion,
ConnectionTime = TimestampHelper.GetUtcNow(),
IsInbound = true
};
if (!IpEndPointHelper.TryParse(NetworkTestConstants.FakeIpEndpoint, out var peerEndpoint))
{
throw new Exception($"Ip {NetworkTestConstants.FakeIpEndpoint} is invalid.");
}
pool.TryAddPeer(new GrpcPeer(new GrpcClient(channel, new PeerService.PeerServiceClient(channel)), peerEndpoint, connectionInfo));
}
public async Task PutExecutiveAsync(Address address, IExecutive executive)
{
if (_smartContractExecutiveProvider.TryGetExecutiveDictionary(address, out var dictionary))
{
if (dictionary.TryGetValue(executive.ContractHash, out var pool))
{
executive.LastUsedTime = TimestampHelper.GetUtcNow();
pool.Add(executive);
return;
}
Logger.LogDebug($"Lost an executive (no registration {address})");
}
else
{
Logger.LogDebug($"Lost an executive (no pool {address})");
}
await Task.CompletedTask;
}
