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);
}
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);
}
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 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 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);
});
}
GenerateTreasuryInitializationCallList()
{
var treasuryContractMethodCallList =
new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
treasuryContractMethodCallList.Add(
nameof(TreasuryContractContainer.TreasuryContractStub.InitialTreasuryContract),
new Empty());
treasuryContractMethodCallList.Add(
nameof(TreasuryContractContainer.TreasuryContractStub.InitialMiningRewardProfitItem),
new Empty());
return(treasuryContractMethodCallList);
}
GenerateTokenInitializationCallList()
{
const string symbol = "ELF";
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContract.Create), new CreateInput
{
Symbol = symbol,
Decimals = 2,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = ProfitContractTestConstants.NativeTokenTotalSupply,
Issuer = Starter,
LockWhiteList =
{
ProfitContractAddress
}
});
// For creating `Treasury` profit scheme.
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = symbol,
Amount = (long)(ProfitContractTestConstants.NativeTokenTotalSupply * 0.12),
To = Address.FromPublicKey(StarterKeyPair.PublicKey),
Memo = "Issue token to default user for vote.",
});
CreatorKeyPair.ForEach(creatorKeyPair => tokenContractCallList.Add(nameof(TokenContract.Issue),
new IssueInput
{
Symbol = symbol,
Amount = (long)(ProfitContractTestConstants.NativeTokenTotalSupply * 0.1),
To = Address.FromPublicKey(creatorKeyPair.PublicKey),
Memo = "set voters few amount for voting."
}));
NormalKeyPair.ForEach(normalKeyPair => tokenContractCallList.Add(nameof(TokenContract.Issue),
new IssueInput
{
Symbol = symbol,
Amount = (long)(ProfitContractTestConstants.NativeTokenTotalSupply * 0.05),
To = Address.FromPublicKey(normalKeyPair.PublicKey),
Memo = "set voters few amount for voting."
}));
return(tokenContractCallList);
}
private async Task StartNodeAsync()
{
var dto = new OsBlockchainNodeContextStartDto
{
ZeroSmartContract = typeof(BasicContractZero),
ChainId = _chainOptions.ChainId
};
dto.SmartContractRunnerCategory = KernelConstants.CodeCoverageRunnerCategory;
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 = TokenTotalSupply,
Decimals = 2,
Issuer = ownAddress,
IsBurnable = true
});
callList.Add(nameof(TokenContractContainer.TokenContractStub.SetPrimaryTokenSymbol),
new SetPrimaryTokenSymbolInput {
Symbol = "ELF"
});
callList.Add(nameof(TokenContractContainer.TokenContractStub.Issue), new IssueInput
{
Symbol = "ELF",
Amount = TokenTotalSupply,
To = ownAddress,
Memo = "Issue"
});
callList.Add(nameof(TokenContractContainer.TokenContractStub.InitialCoefficients), new Empty());
dto.InitializationSmartContracts.AddGenesisSmartContract(
ElectionContractCode,
ElectionSmartContractAddressNameProvider.Name);
dto.InitializationSmartContracts.AddGenesisSmartContract(
TokenContractCode,
TokenSmartContractAddressNameProvider.Name, callList);
_blockchainNodeCtxt = await _osBlockchainNodeContextService.StartAsync(dto);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTokenInitializationCallList(
Address issuer)
{
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.CreateNativeToken), new CreateNativeTokenInput
{
Symbol = _tokenInitialOptions.Symbol,
Decimals = _tokenInitialOptions.Decimals,
IsBurnable = _tokenInitialOptions.IsBurnable,
TokenName = _tokenInitialOptions.Name,
TotalSupply = _tokenInitialOptions.TotalSupply,
// Set the contract zero address as the issuer temporarily.
Issuer = issuer,
LockWhiteSystemContractNameList =
{
ElectionSmartContractAddressNameProvider.Name,
VoteSmartContractAddressNameProvider.Name,
ProfitSmartContractAddressNameProvider.Name,
}
});
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.IssueNativeToken), new IssueNativeTokenInput
{
Symbol = _tokenInitialOptions.Symbol,
Amount = (long)(_tokenInitialOptions.TotalSupply * _tokenInitialOptions.DividendPoolRatio),
ToSystemContractName = ElectionSmartContractAddressNameProvider.Name,
Memo = "Set dividends.",
});
//TODO: Maybe should be removed after testing.
foreach (var tokenReceiver in _consensusOptions.InitialMiners)
{
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.Issue), new IssueInput
{
Symbol = _tokenInitialOptions.Symbol,
Amount = (long)(_tokenInitialOptions.TotalSupply * (1 - _tokenInitialOptions.DividendPoolRatio)) /
_consensusOptions.InitialMiners.Count,
To = Address.FromPublicKey(ByteArrayHelper.FromHexString(tokenReceiver)),
Memo = "Set initial miner's balance."
});
}
// Set fee pool address to election contract address.
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.SetFeePoolAddress),
ElectionSmartContractAddressNameProvider.Name);
return(tokenContractCallList);
}
/// <summary>
/// Zero Contract and Consensus Contract will deploy independently, thus this list won't contain this two contracts.
/// </summary>
/// <returns></returns>
public Action <List <GenesisSmartContractDto> > GetDefaultContractTypes(Address issuer, out long totalSupply,
out long dividend, out long balanceOfStarter)
{
totalSupply = TokenTotalSupply;
dividend = InitialTreasuryAmount;
balanceOfStarter = InitialBalanceOfStarter;
var tokenContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.Create), new CreateInput
{
Symbol = "ELF",
TokenName = "Native token",
TotalSupply = totalSupply,
Decimals = 8,
Issuer = issuer,
IsBurnable = true
});
tokenContractCallList.Add(nameof(TokenContractContainer.TokenContractStub.Issue), new IssueInput
{
Symbol = "ELF",
Amount = balanceOfStarter,
To = Address.FromPublicKey(KeyPair.PublicKey)
});
var crossChainContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
crossChainContractCallList.Add(nameof(CrossChainContractContainer.CrossChainContractStub.Initialize),
new CrossChain.InitializeInput
{
IsPrivilegePreserved = true
});
var parliamentContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
var contractOptions = Application.ServiceProvider.GetService <IOptionsSnapshot <ContractOptions> >().Value;
parliamentContractCallList.Add(nameof(ParliamentAuthContract.Initialize), new ParliamentAuth.InitializeInput
{
GenesisOwnerReleaseThreshold = contractOptions.GenesisOwnerReleaseThreshold
});
return(list =>
{
list.AddGenesisSmartContract(TokenContractCode, TokenSmartContractAddressNameProvider.Name, tokenContractCallList);
list.AddGenesisSmartContract(CrossChainContractCode, CrossChainSmartContractAddressNameProvider.Name, crossChainContractCallList);
list.AddGenesisSmartContract(ParliamentAuthContractCode, ParliamentAuthSmartContractAddressNameProvider.Name,
parliamentContractCallList);
list.AddGenesisSmartContract(ConfigurationContractCode, ConfigurationSmartContractAddressNameProvider.Name);
});
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateReferendumAuthInitializationCallList()
{
var referendumAuthContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
referendumAuthContractCallList.Add(nameof(ReferendumAuthContract.Initialize), new Empty());
return(referendumAuthContractCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTransactionMethodCallList()
{
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(HelloWorldContract.Hello), new Empty());
return(callList);
}
GenerateBingoContractMethodCallList()
{
var callList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
callList.Add(nameof(BingoGameContractContainer.BingoGameContractStub.Initial), new Empty());
return(callList);
}
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
});
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateVoteInitializationCallList()
{
var voteContractMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
voteContractMethodCallList.Add(nameof(VoteContractContainer.VoteContractStub.InitialVoteContract), new Empty());
return(voteContractMethodCallList);
}
GenerateConsensusInitializationCallList()
{
var consensusContractCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusContractCallList.Add(nameof(AEDPoSContractStub.InitialAElfConsensusContract), new InitialAElfConsensusContractInput
{
PeriodSeconds = 604800L,
MinerIncreaseInterval = 31536000
});
consensusContractCallList.Add(nameof(AEDPoSContractStub.FirstRound), new MinerList
{
Pubkeys = { InitialCoreDataCenterKeyPairs.Select(p => ByteString.CopyFrom(p.PublicKey)) }
}.GenerateFirstRoundOfNewTerm(4000, TimestampHelper.GetUtcNow()));
return(consensusContractCallList);
}
private SystemContractDeploymentInput.Types.SystemTransactionMethodCallList GenerateTokenInitializationCallList(
Address issuer, List <string> tokenReceivers)
{
const int totalSupply = 10_0000_0000;
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 = issuer,
LockWhiteSystemContractNameList =
{
ElectionSmartContractAddressNameProvider.Name,
ProfitSmartContractAddressNameProvider.Name,
VoteSmartContractAddressNameProvider.Name
}
});
tokenContractCallList.Add(nameof(TokenContract.IssueNativeToken), new IssueNativeTokenInput
{
Symbol = Symbol,
Amount = totalSupply.Mul(2).Div(10),
ToSystemContractName = ElectionSmartContractAddressNameProvider.Name,
Memo = "Set dividends."
});
foreach (var tokenReceiver in tokenReceivers)
{
tokenContractCallList.Add(nameof(TokenContract.Issue), new IssueInput
{
Symbol = Symbol,
Amount = (long)(totalSupply * 0.8) / tokenReceivers.Count,
To = Address.FromPublicKey(ByteArrayHelpers.FromHexString(tokenReceiver)),
Memo = "Set initial miner's balance.",
});
}
// Set fee pool address to the address of contract in charge of profit item of tx fee.
tokenContractCallList.Add(nameof(TokenContract.SetFeePoolAddress),
ElectionSmartContractAddressNameProvider.Name);
return(tokenContractCallList);
}
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);
}
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);
}));
}
GenerateParliamentInitializationCallList()
{
var parliamentInitializationCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
parliamentInitializationCallList.Add(
nameof(ParliamentContractContainer.ParliamentContractStub.Initialize),
new Contracts.Parliament.InitializeInput());
return(parliamentInitializationCallList);
}
/// <summary>
/// System contract dto for side chain initialization.
/// </summary>
/// <returns></returns>
public Action <List <GenesisSmartContractDto> > GetSideChainSystemContract(Address issuer, int mainChainId,
string symbol,
out long totalSupply,
Address proposer, long parentChainHeightOfCreation = 1, Address parentChainTokenContractAddress = null)
{
totalSupply = TokenTotalSupply;
var nativeTokenInfo = new TokenInfo
{
Symbol = "ELF",
Decimals = 2,
Issuer = issuer,
IsBurnable = true,
TokenName = "elf token",
TotalSupply = TokenTotalSupply,
IssueChainId = ChainHelper.ConvertBase58ToChainId("AELF")
};
var chainOptions = Application.ServiceProvider.GetService <IOptionsSnapshot <ChainOptions> >().Value;
var tokenInitializationCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
tokenInitializationCallList.Add(
nameof(TokenContractContainer.TokenContractStub.Create),
new CreateInput
{
Decimals = nativeTokenInfo.Decimals,
IssueChainId = nativeTokenInfo.IssueChainId,
Issuer = nativeTokenInfo.Issuer,
IsBurnable = nativeTokenInfo.IsBurnable,
Symbol = nativeTokenInfo.Symbol,
TokenName = nativeTokenInfo.TokenName,
TotalSupply = nativeTokenInfo.TotalSupply
});
tokenInitializationCallList.Add(
nameof(TokenContractContainer.TokenContractStub.Create),
new CreateInput
{
Decimals = 2,
IsBurnable = true,
Issuer = Address.FromPublicKey(KeyPair.PublicKey),
TotalSupply = 1_000_000_000,
Symbol = symbol,
TokenName = "TEST",
IssueChainId = chainOptions.ChainId
}
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);
}
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
});
GenerateConsensusInitializationCallList(ConsensusOptions consensusOptions)
{
var consensusMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.InitialAElfConsensusContract),
new InitialAElfConsensusContractInput
{
IsTermStayOne = true
});
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.FirstRound),
new MinerList
{
Pubkeys =
{
consensusOptions.InitialMinerList.Select(k => k.ToByteString())
}
}.GenerateFirstRoundOfNewTerm(consensusOptions.MiningInterval,
consensusOptions.StartTimestamp));
return(consensusMethodCallList);
}
GenerateConsensusInitializationCallList(List <string> initialMiners,
int miningInterval, Timestamp startTimestamp)
{
var consensusMethodCallList = new SystemContractDeploymentInput.Types.SystemTransactionMethodCallList();
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.InitialAElfConsensusContract),
new InitialAElfConsensusContractInput
{
IsSideChain = true
});
consensusMethodCallList.Add(nameof(AEDPoSContractContainer.AEDPoSContractStub.FirstRound),
new MinerList
{
Pubkeys =
{
initialMiners.Select(k => k.ToByteString())
}
}.GenerateFirstRoundOfNewTerm(miningInterval, startTimestamp));
return(consensusMethodCallList);
}