private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTransactionMethodCallList()
{
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(HelloWorldContract.Hello), new Empty());
return(callList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTokenInitializationCallList()
{
const long totalSupply = 1_000_000_000_0000_0000;
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.Create), new CreateInput
{
Symbol = TestTokenSymbol,
Decimals = 2,
IsBurnable = true,
TokenName = "elf token for testing",
TotalSupply = totalSupply,
Issuer = DefaultSender,
LockWhiteList =
{
VoteContractAddress
}
});
//issue default user
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = TestTokenSymbol,
Amount = totalSupply - 20 * 100_000_0000_0000L,
To = DefaultSender,
Memo = "Issue token to default user for vote.",
});
GenerateEconomicInitializationCallList()
{
var economicContractMethodCallList =
new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
economicContractMethodCallList.Add(
nameof(EconomicContractContainer.EconomicContractStub.InitialEconomicSystem),
new InitialEconomicSystemInput
{
NativeTokenDecimals = _economicOptions.Decimals,
IsNativeTokenBurnable = _economicOptions.IsBurnable,
NativeTokenSymbol = _economicOptions.Symbol,
NativeTokenName = _economicOptions.TokenName,
NativeTokenTotalSupply = _economicOptions.TotalSupply,
MiningRewardTotalAmount =
Convert.ToInt64(_economicOptions.TotalSupply * _economicOptions.DividendPoolRatio),
TransactionSizeFeeUnitPrice = _economicOptions.TransactionSizeFeeUnitPrice
});
//TODO: Maybe should be removed after testing.
economicContractMethodCallList.Add(
nameof(EconomicContractContainer.EconomicContractStub.IssueNativeToken), new IssueNativeTokenInput
{
Amount = Convert.ToInt64(_economicOptions.TotalSupply * (1 - _economicOptions.DividendPoolRatio)),
To = Address.FromPublicKey(
ByteArrayHelper.HexStringToByteArray(_consensusOptions.InitialMinerList.First())),
Memo = "Issue native token"
});
return(economicContractMethodCallList);
}
GenerateReferendumInitializationCallList()
{
var referendumInitializationCallList =
new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
return(referendumInitializationCallList);
}
GenerateConsensusInitializationCallList()
{
var aelfConsensusMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
aelfConsensusMethodCallList.Add(
nameof(AEDPoSContractContainer.AEDPoSContractStub.InitialAElfConsensusContract),
new InitialAElfConsensusContractInput
{
PeriodSeconds = _consensusOptions.PeriodSeconds,
MinerIncreaseInterval = _consensusOptions.MinerIncreaseInterval,
IsTermStayOne = true
});
var firstRound = new MinerList
{
Pubkeys =
{
_consensusOptions.InitialMinerList.Select(p => p.ToByteString())
}
}.GenerateFirstRoundOfNewTerm(_consensusOptions.MiningInterval,
_consensusOptions.StartTimestamp.ToDateTime());
aelfConsensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.FirstRound),
firstRound);
return(aelfConsensusMethodCallList);
}
GenerateConsensusInitializationCallList(ChainInitializationData chainInitializationData)
{
var consensusMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
var miners = chainInitializationData == null
? new MinerList
{
Pubkeys =
{
_consensusOptions.InitialMinerList.Select(p => p.ToByteString())
}
}
: MinerListWithRoundNumber.Parser
.ParseFrom(chainInitializationData.ChainInitializationConsensusInfo.InitialMinerListData).MinerList;
var timestamp = chainInitializationData?.CreationTimestamp ?? _consensusOptions.StartTimestamp;
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.InitialAElfConsensusContract),
new InitialAElfConsensusContractInput
{
IsSideChain = true,
PeriodSeconds = _consensusOptions.PeriodSeconds
});
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.FirstRound),
miners.GenerateFirstRoundOfNewTerm(_consensusOptions.MiningInterval, timestamp));
return(consensusMethodCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateReferendumAuthInitializationCallList()
{
var referendumAuthContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
referendumAuthContractCallList.Add(nameof(ReferendumAuthContract.Initialize), new Empty());
return(referendumAuthContractCallList);
}
GenerateConfigurationInitializationCallList(ChainInitializationData chainInitializationData)
{
var configurationContractMethodCallList =
new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
return(configurationContractMethodCallList);
}
private Transaction GetTransactionForDeployment(int chainId, Type contractType, Hash systemContractName,
int category, SystemContractDeploymentInput.Types.SystemTransactionMethodCallList transactionMethodCallList = null)
{
if (transactionMethodCallList == null)
{
transactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
}
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
var code = File.ReadAllBytes(contractType.Assembly.Location);
return(new Transaction()
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ISmartContractZero.DeploySystemSmartContract),
// TODO: change cagtegory to 0
Params = new SystemContractDeploymentInput()
{
Name = systemContractName,
Category = category,
Code = ByteString.CopyFrom(code),
TransactionMethodCallList = transactionMethodCallList
}.ToByteString()
});
}
private async Task StartNodeAsync()
{
var dto = new OsBlockchainNodeContextStartDto
{
ZeroSmartContract = typeof(BasicContractZero),
ChainId = _chainOptions.ChainId
};
dto.InitializationSmartContracts.AddGenesisSmartContract(
ConsensusContractCode,
ConsensusSmartContractAddressNameProvider.Name);
var ownAddress = await _accountService.GetAccountAsync();
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(TokenContractContainer.TokenContractStub.Create), new CreateInput
{
Symbol = "ELF",
TokenName = "ELF_Token",
TotalSupply = 1000_0000L,
Decimals = 2,
Issuer = ownAddress,
IsBurnable = true
});
GenerateBingoContractMethodCallList()
{
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(BingoGameContractContainer.BingoGameContractStub.Initial), new Empty());
return(callList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTokenInitializationCallList()
{
const string symbol = "ELF";
const long totalSupply = 100_000_000;
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.CreateNativeToken), new CreateNativeTokenInput
{
Symbol = symbol,
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = totalSupply,
Issuer = DefaultSender,
LockWhiteSystemContractNameList =
{
Hash.FromString("AElf.ContractNames.Vote")
}
});
//issue default user
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = symbol,
Amount = totalSupply - 3500_000L,
To = DefaultSender,
Memo = "Issue token to default user for vote.",
});
private Transaction GetTransactionForDeployment(byte[] code, Hash systemContractName,
int category,
List <ContractInitializationMethodCall> contractInitializationMethodCallList = null)
{
var transactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
if (contractInitializationMethodCallList != null)
{
transactionMethodCallList.Value.Add(contractInitializationMethodCallList.Select(call =>
new SystemContractDeploymentInput.Types.SystemTransactionMethodCall
{
MethodName = call.MethodName,
Params = call.Params ?? ByteString.Empty
}));
}
var zeroAddress = _smartContractAddressService.GetZeroSmartContractAddress();
return(new Transaction()
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.DeploySystemSmartContract),
Params = new SystemContractDeploymentInput()
{
Name = systemContractName,
Category = category,
Code = ByteString.CopyFrom(code),
TransactionMethodCallList = transactionMethodCallList
}.ToByteString()
});
}
private Transaction GetTransactionForDeployment(Type contractType, Hash systemContractName,
int category,
SystemContractDeploymentInput.Types.SystemTransactionMethodCallList transactionMethodCallList = null)
{
var code = File.ReadAllBytes(contractType.Assembly.Location);
return(GetTransactionForDeployment(code, systemContractName, category, transactionMethodCallList));
}
GenerateCrossChainInitializationCallList()
{
var crossChainMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
crossChainMethodCallList.Add(nameof(CrossChainContractContainer.CrossChainContractStub.Initialize),
new InitializeInput());
return(crossChainMethodCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateProfitInitializationCallList()
{
var profitContractMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
profitContractMethodCallList.Add(nameof(ProfitContractContainer.ProfitContractStub.InitializeProfitContract), new Empty());
return(profitContractMethodCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateVoteInitializationCallList()
{
var voteContractMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
voteContractMethodCallList.Add(nameof(VoteContractContainer.VoteContractStub.InitialVoteContract), new Empty());
return(voteContractMethodCallList);
}
internal static void Add(this SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList, string methodName,
IMessage input)
{
systemTransactionMethodCallList.Value.Add(new SystemContractDeploymentInput.Types.SystemTransactionMethodCall()
{
MethodName = methodName,
Params = input?.ToByteString() ?? ByteString.Empty
});
}
GenerateParliamentInitializationCallList()
{
var parliamentInitializationCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
parliamentInitializationCallList.Add(
nameof(ParliamentContractContainer.ParliamentContractStub.Initialize),
new Contracts.Parliament.InitializeInput());
return(parliamentInitializationCallList);
}
public static void AddGenesisSmartContract <T>(this List <GenesisSmartContractDto> genesisSmartContracts,
Hash name, Action <SystemContractDeploymentInput.Types.SystemTransactionMethodCallList> action)
{
SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
action?.Invoke(systemTransactionMethodCallList);
genesisSmartContracts.AddGenesisSmartContract <T>(name, systemTransactionMethodCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateReferendumAuthInitializationCallList()
{
var referendumAuthContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
referendumAuthContractCallList.Add(nameof(ReferendumAuthContract.Initialize), new ReferendumAuthContractInitializationInput
{
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name
});
return(referendumAuthContractCallList);
}
GenerateTokenInitializationCallList()
{
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.InitializeTokenContract), new IntializeTokenContractInput
{
CrossChainContractSystemName = CrossChainSmartContractAddressNameProvider.Name
});
return(tokenContractCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateBingoContractMethodCallList()
{
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(BingoGameContract.InitialBingoGame), new InitialBingoGameInput
{
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name,
TokenContractSystemName = TokenConverterSmartContractAddressNameProvider.Name
});
return(callList);
}
GenerateParliamentInitializationCallList()
{
var parliamentInitializationCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
parliamentInitializationCallList.Add(nameof(ParliamentAuthContract.Initialize),
new ParliamentAuthInitializationInput
{
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name
});
return(parliamentInitializationCallList);
}
GenerateBingoGameInitializationCallList()
{
var bingoGameMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
bingoGameMethodCallList.Add(nameof(BingoGameContract.BingoGameContract.InitialBingoGame), new InitialBingoGameInput
{
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name,
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name
});
return(bingoGameMethodCallList);
}
public static void AddGenesisSmartContract(this List <GenesisSmartContractDto> genesisSmartContracts,
byte[] code, Hash name = null,
SystemContractDeploymentInput.Types.SystemTransactionMethodCallList systemTransactionMethodCallList = null)
{
genesisSmartContracts.Add(new GenesisSmartContractDto()
{
Code = code,
SystemSmartContractName = name,
TransactionMethodCallList = systemTransactionMethodCallList
});
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateConsensusInitializationCallList(DPoSOptions dposOptions)
{
var consensusMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusMethodCallList.Add(nameof(ConsensusContract.InitialDPoSContract),
new Consensus.DPoS.InitialDPoSContractInput
{
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name,
DividendsContractSystemName = DividendSmartContractAddressNameProvider.Name,
LockTokenForElection = 100_000
});
private Transaction GetTransactionForDeployment(Type contractType, Hash systemContractName,
int category,
SystemContractDeploymentInput.Types.SystemTransactionMethodCallList transactionMethodCallList = null)
{
var dllPath = Directory.Exists(_contractOptions.GenesisContractDir)
? Path.Combine(_contractOptions.GenesisContractDir, $"{contractType.Assembly.GetName().Name}.dll")
: contractType.Assembly.Location;
var code = File.ReadAllBytes(dllPath);
return(GetTransactionForDeployment(code, systemContractName, category, transactionMethodCallList));
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTokenInitializationCallList(
ChainInitializationData chainInitializationData)
{
var nativeTokenInfo = TokenInfo.Parser.ParseFrom(chainInitializationData.ExtraInformation[1]);
var resourceTokenList = TokenInfoList.Parser.ParseFrom(chainInitializationData.ExtraInformation[2]);
var chainPrimaryTokenInfo = TokenInfo.Parser.ParseFrom(chainInitializationData.ExtraInformation[3]);
var tokenInitializationCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenInitializationCallList.Add(
nameof(TokenContractContainer.TokenContractStub.RegisterNativeAndResourceTokenInfo),
new RegisterNativeAndResourceTokenInfoInput
{
NativeTokenInfo =
new RegisterNativeTokenInfoInput
{
Decimals = nativeTokenInfo.Decimals,
IssueChainId = nativeTokenInfo.IssueChainId,
Issuer = nativeTokenInfo.Issuer,
IsBurnable = nativeTokenInfo.IsBurnable,
Symbol = nativeTokenInfo.Symbol,
TokenName = nativeTokenInfo.TokenName,
TotalSupply = nativeTokenInfo.TotalSupply,
IsProfitable = nativeTokenInfo.IsProfitable
},
ResourceTokenList = resourceTokenList,
ChainPrimaryToken = chainPrimaryTokenInfo
});
foreach (var issueStuff in chainInitializationData.SideChainTokenInitialIssueList)
{
tokenInitializationCallList.Add(nameof(TokenContractContainer.TokenContractStub.Issue), new IssueInput
{
Symbol = chainPrimaryTokenInfo.Symbol,
Amount = issueStuff.Amount,
Memo = "Initial issue",
To = issueStuff.Address
});
}
tokenInitializationCallList.Add(nameof(TokenContractContainer.TokenContractStub.Initialize),
new InitializeInput
{
ResourceAmount =
{
chainInitializationData.InitialResourceAmount.ToDictionary(kv => kv.Key.ToUpper(),
kv => kv.Value)
}
});
tokenInitializationCallList.Add(nameof(TokenContractContainer.TokenContractStub.SetSideChainCreator),
chainInitializationData.Creator);
return(tokenInitializationCallList);
}
public static async Task InitialChainAndTokenAsync(
this ContractTester <DPoSContractTestAElfModule> starter, List <ECKeyPair> minersKeyPairs = null,
int miningInterval = 4000, Timestamp blockchainStartTimestamp = null)
{
var dividendMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
dividendMethodCallList.Add(nameof(DividendContract.InitializeDividendContract),
new InitialDividendContractInput
{
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name,
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name
});
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 elf token."
});
// For testing.
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = "ELF",
Amount = DPoSContractConsts.LockTokenForElection * 80,
To = starter.GetCallOwnerAddress(),
Memo = "Set dividends."
});
await starter.InitialCustomizedChainAsync(minersKeyPairs?.Select(m => m.PublicKey.ToHex()).ToList(),
miningInterval, blockchainStartTimestamp,
list =>
{
// Dividends contract must be deployed before token contract.
list.AddGenesisSmartContract <DividendContract>(DividendSmartContractAddressNameProvider.Name,
dividendMethodCallList);
list.AddGenesisSmartContract <TokenContract>(TokenSmartContractAddressNameProvider.Name,
tokenContractCallList);
});
}
