internal async Task <long> GetParentChainHeight(
ContractTester <MultiTokenContractCrossChainTestAElfModule> tester, Address sideCrossChainContract)
{
var result = await tester.CallContractMethodAsync(sideCrossChainContract,
nameof(CrossChainContractContainer.CrossChainContractStub
.GetParentChainHeight), new Empty());
var height = Int64Value.Parser.ParseFrom(result);
return(height.Value);
}
public async Task InitialChainTest()
{
var tester = new ContractTester <ContractTestAElfModule>();
await tester.InitialChainAsync();
var chain = await tester.GetChainAsync();
var longestChainHeight = chain.LongestChainHeight;
Assert.Equal(1, longestChainHeight);
}
public static async Task <TransactionResult> TransferTokenAsync(
this ContractTester <DPoSContractTestAElfModule> contractTester,
Address receiverAddress, long amount)
{
return(await contractTester.ExecuteTokenContractMethodWithMiningAsync(nameof(TokenContract.Transfer),
new TransferInput
{
To = receiverAddress,
Amount = amount,
Symbol = "ELF",
}));
}
public static async Task <TransactionResult> Vote(this ContractTester <DPoSContractTestAElfModule> voter,
string publicKey,
long amount, int lockTime)
{
return(await voter.ExecuteConsensusContractMethodWithMiningAsync(nameof(ConsensusContract.Vote),
new VoteInput()
{
CandidatePublicKey = publicKey,
Amount = amount,
LockTime = lockTime
}));
}
internal async Task <TransactionResult> ApproveWithKeyPairAsync(
ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId,
ECKeyPair ecKeyPair)
{
var testerWithMiner = tester.CreateNewContractTester(ecKeyPair);
return(await testerWithMiner.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput
{
ProposalId = proposalId
}));
}
public ParliamentContractPrivilegeTestBase()
{
var mainChainId = ChainHelper.ConvertBase58ToChainId("AELF");
var chainId = ChainHelper.GetChainId(1);
Tester = new ContractTester<ParliamentContractPrivilegeTestAElfModule>(chainId,SampleECKeyPairs.KeyPairs[1]);
AsyncHelper.RunSync(() =>
Tester.InitialChainAsyncWithAuthAsync(Tester.GetSideChainSystemContract(
Tester.GetCallOwnerAddress(),
mainChainId,"STA",out TotalSupply,Tester.GetCallOwnerAddress())));
ParliamentAddress = Tester.GetContractAddress(ParliamentSmartContractAddressNameProvider.Name);
TokenContractAddress = Tester.GetContractAddress(TokenSmartContractAddressNameProvider.Name);
}
public ElectionTest()
{
// The starter initial chain and tokens.
Starter = new ContractTester <DPoSContractTestAElfModule>();
var minersKeyPairs = Enumerable.Range(0, MinersCount - 1).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
minersKeyPairs.Add(Starter.KeyPair);
AsyncHelper.RunSync(() => Starter.InitialChainAndTokenAsync(minersKeyPairs));
Miners = Enumerable.Range(0, MinersCount)
.Select(i => Starter.CreateNewContractTester(minersKeyPairs[i])).ToList();
}
public ViewTest()
{
// The starter initial chain and tokens.
Starter = new ContractTester <DPoSContractTestAElfModule>();
MinersKeyPairs = Enumerable.Range(0, MinersCount - 1).Select(_ => CryptoHelpers.GenerateKeyPair()).ToList();
// Enable Start to use SetBlockchainAge method.
MinersKeyPairs.Add(Starter.KeyPair);
AsyncHelper.RunSync(() => Starter.InitialChainAndTokenAsync(MinersKeyPairs));
MinerList = Enumerable.Range(0, MinersCount)
.Select(i => Starter.CreateNewContractTester(MinersKeyPairs[i])).ToList();
}
public MultiTokenContractCrossChainTestBase()
{
MainChainId = ChainHelper.ConvertBase58ToChainId("AELF");
MainChainTester = new ContractTester <MultiTokenContractCrossChainTestAElfModule>(MainChainId, SampleECKeyPairs.KeyPairs[1]);
AsyncHelper.RunSync(() =>
MainChainTester.InitialChainAsyncWithAuthAsync(MainChainTester.GetDefaultContractTypes(MainChainTester.GetCallOwnerAddress(), out TotalSupply,
out _,
out BalanceOfStarter)));
BasicContractZeroAddress = MainChainTester.GetZeroContractAddress();
CrossChainContractAddress = MainChainTester.GetContractAddress(CrossChainSmartContractAddressNameProvider.Name);
TokenContractAddress = MainChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name);
ParliamentAddress = MainChainTester.GetContractAddress(ParliamentAuthSmartContractAddressNameProvider.Name);
}
public static async Task InitialChainAndTokenAsync(this ContractTester <FeeReceiverContractTestAElfModule> starter)
{
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.Create), new CreateInput
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = 1000_0000L,
Issuer = starter.GetCallOwnerAddress()
});
public static async Task <long> GetBalanceAsync(this ContractTester <MultiTokenContractTestAElfModule> contractTester,
Address targetAddress)
{
var balanceOutput = GetBalanceOutput.Parser.ParseFrom(
await contractTester.CallContractMethodAsync(contractTester.GetTokenContractAddress(),
nameof(TokenContract.GetBalance), new GetBalanceInput
{
Owner = targetAddress,
Symbol = "ELF"
}));
return(balanceOutput.Balance);
}
internal async Task <Address> DeployAsync(ContractTester <BasicContractZeroTestAElfModule> tester,
Address parliamentContract, ContractDeploymentInput contractDeploymentInput)
{
var proposingTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ProposeNewContract), contractDeploymentInput);
var proposalCreatedEvent =
proposingTxResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ProposalCreated)));
if (proposalCreatedEvent == null)
{
return(null);
}
var proposalId = ProposalCreated.Parser
.ParseFrom(proposalCreatedEvent.NonIndexed)
.ProposalId;
var proposedContractInputHash = ContractProposed.Parser
.ParseFrom(proposingTxResult.Logs.First(l => l.Name.Contains(nameof(ContractProposed))).NonIndexed)
.ProposedContractInputHash;
await ApproveWithMinersAsync(Tester, ParliamentAddress, proposalId);
// release contract code and trigger code check proposal
var releaseApprovedContractTxResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZero.ReleaseApprovedContract), new ReleaseContractInput
{
ProposalId = proposalId,
ProposedContractInputHash = proposedContractInputHash
});
var codeCheckProposalId = ProposalCreated.Parser
.ParseFrom(releaseApprovedContractTxResult.Logs.First(l => l.Name.Contains(nameof(ProposalCreated)))
.NonIndexed).ProposalId;
await ApproveWithMinersAsync(Tester, ParliamentAddress, codeCheckProposalId);
// release code check proposal and deployment completes
var deploymentResult = await tester.ExecuteContractWithMiningAsync(BasicContractZeroAddress,
nameof(BasicContractZeroContainer.BasicContractZeroStub.ReleaseCodeCheckedContract),
new ReleaseContractInput
{ ProposedContractInputHash = proposedContractInputHash, ProposalId = codeCheckProposalId });
var deploymentEvent = deploymentResult.Logs.FirstOrDefault(l => l.Name.Contains(nameof(ContractDeployed)));
var address = deploymentEvent != null
? ContractDeployed.Parser.ParseFrom(deploymentEvent.NonIndexed).Address
: null;
return(address);
}
protected async Task <Address> CreateOrganizationAsync(ContractTester <BasicContractZeroTestAElfModule> tester,
Address parliamentContract)
{
var createOrganizationInput = new CreateOrganizationInput
{
ReleaseThreshold = 20000 / tester.InitialMinerList.Count
};
var transactionResult =
await tester.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.CreateOrganization),
createOrganizationInput);
return(Address.Parser.ParseFrom(transactionResult.ReturnValue));
}
public static async Task InitialChainAndTokenAsync(this ContractTester <ResourceContractTestAElfModule> starter)
{
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.CreateNativeToken), new CreateNativeTokenInput
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = 1000_0000L,
Issuer = starter.GetCallOwnerAddress(),
LockWhiteSystemContractNameList = { ConsensusSmartContractAddressNameProvider.Name }
});
public static async Task <List <Transaction> > GenerateConsensusTransactionsAsync(
this ContractTester <DPoSContractTestAElfModule> tester,
DPoSTriggerInformation triggerInformation)
{
var bytes = await tester.CallContractMethodAsync(tester.GetConsensusContractAddress(),
ConsensusConsts.GenerateConsensusTransactions, triggerInformation);
var txs = TransactionList.Parser.ParseFrom(bytes).Transactions.ToList();
tester.SignTransaction(ref txs, tester.KeyPair);
tester.SupplyTransactionParameters(ref txs);
return(txs);
}
public static async Task <Tickets> GetPageableNotWithdrawnTicketsInfo(
this ContractTester <DPoSContractTestAElfModule> contractTester, string publicKey, int startIndex,
int length)
{
var bytes = await contractTester.CallContractMethodAsync(contractTester.GetConsensusContractAddress(),
nameof(ConsensusContract.GetPageableNotWithdrawnTicketsInfo),
new PageableTicketsInfoInput()
{
PublicKey = publicKey,
Start = startIndex,
Length = length
});
return(Tickets.Parser.ParseFrom(bytes));
}
public static async Task <ConsensusCommand> GetConsensusCommandAsync(
this ContractTester <DPoSSideChainTestAElfModule> tester,
Timestamp timestamp = null)
{
var triggerInformation = new DPoSTriggerInformation
{
PublicKey = ByteString.CopyFrom(tester.KeyPair.PublicKey),
};
var bytes = await tester.CallContractMethodAsync(
tester.GetConsensusContractAddress(), // Usually the second contract is consensus contract.
ConsensusConsts.GetConsensusCommand,
triggerInformation);
return(ConsensusCommand.Parser.ParseFrom(bytes));
}
public static async Task <TransactionResult> AnnounceElectionAsync(
this ContractTester <DPoSContractTestAElfModule> candidate, string alias = null)
{
if (alias == null)
{
alias = candidate.KeyPair.PublicKey.ToHex().Substring(0, DPoSContractConsts.AliasLimit);
}
return(await candidate.ExecuteContractWithMiningAsync(candidate.GetConsensusContractAddress(),
nameof(ConsensusContract.AnnounceElection),
new Alias()
{
Value = alias
}));
}
/// <summary>
/// Default pocket money is 10000L.
/// </summary>
/// <param name="starter"></param>
/// <param name="number"></param>
/// <param name="pocketMoney"></param>
/// <returns></returns>
public static async Task <List <ContractTester <DPoSContractTestAElfModule> > > GenerateVotersAsync(
this ContractTester <DPoSContractTestAElfModule> starter, int number = 1, long pocketMoney = 10000L)
{
var voters = new List <ContractTester <DPoSContractTestAElfModule> >();
for (var i = 0; i < number; i++)
{
var voter = starter.CreateNewContractTester(CryptoHelpers.GenerateKeyPair());
await starter.TransferTokenAsync(voter.GetCallOwnerAddress(), pocketMoney);
voters.Add(voter);
}
return(voters);
}
public static async Task <ConsensusCommand> GetConsensusCommandAsync(
this ContractTester <DPoSContractTestAElfModule> tester,
Timestamp timestamp)
{
var commandInput = new CommandInput
{
PublicKey = ByteString.CopyFrom(tester.KeyPair.PublicKey),
};
var bytes = await tester.CallContractMethodAsync(
tester.GetConsensusContractAddress(), // Usually the second contract is consensus contract.
ConsensusConsts.GetConsensusCommand,
commandInput, timestamp.ToDateTime());
return(ConsensusCommand.Parser.ParseFrom(bytes));
}
public void InitialTesters()
{
for (var i = 0; i < MinersCount; i++)
{
var keyPair = CryptoHelpers.GenerateKeyPair();
MinersKeyPairs.Add(keyPair);
var tester = new ContractTester <DPoSSideChainTestAElfModule>(ChainId, keyPair);
AsyncHelper.RunSync(
() => tester.InitialSideChainAsync());
Testers.Add(tester);
}
DPoSSideChainContractAddress = Testers[0].GetConsensusContractAddress();
}
public static async Task <TransactionResult> Unlock(this ContractTester <MultiTokenContractTestAElfModule> contractTester, long amount,
Hash lockId)
{
return(await contractTester.ExecuteContractWithMiningAsync(contractTester.GetTokenContractAddress(),
nameof(TokenContract.Unlock),
new UnlockInput
{
From = contractTester.GetCallOwnerAddress(),
To = contractTester.GetConsensusContractAddress(),
Amount = amount,
Symbol = "ELF",
LockId = lockId,
Usage = "Testing."
}));
}
protected async Task ApproveWithMinersAsync(
ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId)
{
var tester0 = tester.CreateNewContractTester(Tester.InitialMinerList[0]);
await tester0.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId);
var tester1 = tester.CreateNewContractTester(Tester.InitialMinerList[1]);
await tester1.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId);
var tester2 = tester.CreateNewContractTester(Tester.InitialMinerList[2]);
await tester2.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentContractContainer.ParliamentContractStub.Approve), proposalId);
}
protected void StartSideChain(int chainId, long height)
{
SideChainTester =
new ContractTester <MultiTokenContractCrossChainTestAElfModule>(chainId, SampleECKeyPairs.KeyPairs[0]);
AsyncHelper.RunSync(() =>
SideChainTester.InitialCustomizedChainAsync(chainId,
configureSmartContract: SideChainTester.GetSideChainSystemContract(
SideChainTester.GetCallOwnerAddress(), MainChainId, out TotalSupply, SideChainTester.GetCallOwnerAddress(), height)));
SideBasicContractZeroAddress = SideChainTester.GetZeroContractAddress();
SideCrossChainContractAddress =
SideChainTester.GetContractAddress(CrossChainSmartContractAddressNameProvider.Name);
SideTokenContractAddress = SideChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name);
SideParliamentAddress =
SideChainTester.GetContractAddress(ParliamentAuthSmartContractAddressNameProvider.Name);
SideConsensusAddress = SideChainTester.GetContractAddress(ConsensusSmartContractAddressNameProvider.Name);
}
public LockTest()
{
Starter = new ContractTester <MultiTokenContractTestAElfModule>();
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.CreateNativeToken), new CreateNativeTokenInput
{
Symbol = "ELF",
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
Issuer = Starter.GetCallOwnerAddress(),
TotalSupply = DPoSContractConsts.LockTokenForElection * 100,
LockWhiteSystemContractNameList = { ConsensusSmartContractAddressNameProvider.Name }
});
tokenContractCallList.Add(nameof(TokenContract.IssueNativeToken), new IssueNativeTokenInput
{
Symbol = "ELF",
Amount = DPoSContractConsts.LockTokenForElection * 20,
ToSystemContractName = DividendSmartContractAddressNameProvider.Name,
Memo = "Issue ",
});
// For testing.
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = "ELF",
Amount = DPoSContractConsts.LockTokenForElection * 80,
To = Starter.GetCallOwnerAddress(),
Memo = "Set dividends.",
});
AsyncHelper.RunSync(() => Starter.InitialChainAsync(list =>
{
list.AddGenesisSmartContract <DividendContract>(DividendSmartContractAddressNameProvider.Name);
//test extension AddGenesisSmartContract<T>(this List<GenesisSmartContractDto> genesisSmartContracts, Hash name, Action<SystemTransactionMethodCallList> action)
void Action(SystemContractDeploymentInput.Types.SystemTransactionMethodCallList x)
{
x.Value.Add(tokenContractCallList.Value);
}
list.AddGenesisSmartContract <TokenContract>(TokenSmartContractAddressNameProvider.Name, Action);
}));
}
protected async Task <TransactionResult> ApproveWithMinersAsync(
ContractTester <BasicContractZeroTestAElfModule> tester, Address parliamentContract, Hash proposalId)
{
var tester0 = tester.CreateNewContractTester(Tester.InitialMinerList[0]);
await tester0.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput
{
ProposalId = proposalId
});
var tester1 = tester.CreateNewContractTester(Tester.InitialMinerList[1]);
var txResult2 = await tester1.ExecuteContractWithMiningAsync(parliamentContract,
nameof(ParliamentAuthContractContainer.ParliamentAuthContractStub.Approve), new ApproveInput
{
ProposalId = proposalId
});
return(txResult2);
}
protected async Task <Hash> CreateProposalAsync(ContractTester <ConfigurationContractTestAElfModule> tester,
Address contractAddress, Address organizationAddress, string methodName, IMessage input)
{
var configContract = tester.GetContractAddress(Hash.FromString("AElf.ContractNames.Configuration"));
var proposal = await tester.ExecuteContractWithMiningAsync(contractAddress,
nameof(AuthorizationContractContainer.AuthorizationContractStub.CreateProposal),
new CreateProposalInput
{
ContractMethodName = methodName,
ExpiredTime = DateTime.UtcNow.AddDays(1).ToTimestamp(),
Params = input.ToByteString(),
ToAddress = configContract,
OrganizationAddress = organizationAddress
});
var proposalId = Hash.Parser.ParseFrom(proposal.ReturnValue);
return(proposalId);
}
protected void StartSideChain()
{
var chainId = ChainHelper.ConvertBase58ToChainId("Side");
var mainChainId = Tester.GetChainAsync().Result.Id;
SideChainTester =
new ContractTester <BasicContractZeroTestAElfModule>(chainId, CreatorKeyPair);
AsyncHelper.RunSync(() =>
SideChainTester.InitialCustomizedChainAsync(chainId,
configureSmartContract: SideChainTester.GetSideChainSystemContract(
SideChainTester.GetCallOwnerAddress(), mainChainId, "STA", out TotalSupply,
SideChainTester.GetCallOwnerAddress())));
SideBasicContractZeroAddress = SideChainTester.GetZeroContractAddress();
SideTokenContractAddress = SideChainTester.GetContractAddress(TokenSmartContractAddressNameProvider.Name);
SideParliamentAddress =
SideChainTester.GetContractAddress(ParliamentSmartContractAddressNameProvider.Name);
SideChainMinerTester = SideChainTester.CreateNewContractTester(SideChainTester.InitialMinerList.First());
}
protected async Task <Hash> CreateProposalAsync(ContractTester <BasicContractZeroTestAElfModule> tester,
Address contractAddress, Address organizationAddress, string methodName, IMessage input)
{
var basicContract = tester.GetZeroContractAddress();
// var organizationAddress = await GetGenesisAddressAsync(tester, parliamentContractAddress);
var proposal = await tester.ExecuteContractWithMiningAsync(contractAddress,
nameof(AuthorizationContractContainer.AuthorizationContractStub.CreateProposal),
new CreateProposalInput
{
ContractMethodName = methodName,
ExpiredTime = DateTime.UtcNow.AddDays(1).ToTimestamp(),
Params = input.ToByteString(),
ToAddress = basicContract,
OrganizationAddress = organizationAddress
});
var proposalId = Hash.Parser.ParseFrom(proposal.ReturnValue);
return(proposalId);
}
public void InitialTesters(Timestamp blockchainStartTime)
{
for (var i = 0; i < MinersCount; i++)
{
var keyPair = CryptoHelpers.GenerateKeyPair();
MinersKeyPairs.Add(keyPair);
}
foreach (var minersKeyPair in MinersKeyPairs)
{
var tester = new ContractTester <DPoSContractTestAElfModule>(ChainId, minersKeyPair);
AsyncHelper.RunSync(() =>
tester.InitialCustomizedChainAsync(MinersKeyPairs.Select(m => m.PublicKey.ToHex()).ToList(), 4000,
blockchainStartTime));
Testers.Add(tester);
}
AsyncHelper.RunSync(() => Testers.RunConsensusAsync(2));
ConsensusContractAddress = Testers[0].GetConsensusContractAddress();
}
