private async Task <VotingItem> RegisterVotingItemAsync(int lastingDays, int optionsCount, bool isLockToken, Address sender,
int totalSnapshotNumber = int.MaxValue)
{
var startTime = TimestampHelper.GetUtcNow();
var options = Enumerable.Range(0, optionsCount).Select(_ => SampleAddress.AddressList[0].GetFormatted()).ToList();
var input = new VotingRegisterInput
{
TotalSnapshotNumber = totalSnapshotNumber,
EndTimestamp = startTime.AddDays(lastingDays),
StartTimestamp = startTime,
Options = { options },
AcceptedCurrency = EconomicSystemTestConstants.NativeTokenSymbol,
IsLockToken = isLockToken
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
input.Options.Clear();
var votingItemId = Hash.FromTwoHashes(Hash.FromMessage(input), Hash.FromMessage(sender));
return(await VoteContractStub.GetVotingItem.CallAsync(new GetVotingItemInput
{
VotingItemId = votingItemId
}));
}
public async Task VoteContract_RegisterSuccess()
{
_options = GenerateOptions(3);
var input = new VotingRegisterInput
{
Topic = "Topic1",
TotalEpoch = 1,
ActiveDays = 100,
StartTimestamp = DateTime.UtcNow.ToTimestamp(),
Options =
{
_options
},
AcceptedCurrency = "ELF"
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
//register again
transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Voting event already exists").ShouldBeTrue();
}
public static Hash GetHash(this VotingRegisterInput votingItemInput, Address sponsorAddress)
{
var input = votingItemInput.Clone();
input.Options.Clear();
return(HashHelper.ConcatAndCompute(HashHelper.ComputeFrom(input), HashHelper.ComputeFrom(sponsorAddress)));
}
public static Hash GetHash(this VotingRegisterInput votingItemInput, Address sponsorAddress)
{
var input = votingItemInput.Clone();
input.Options.Clear();
return(Hash.FromTwoHashes(Hash.FromMessage(input), Hash.FromMessage(sponsorAddress)));
}
public override Empty Register(VotingRegisterInput input)
{
var votingItemId = AssertValidNewVotingItem(input);
if (State.TokenContract.Value == null)
{
State.TokenContract.Value =
Context.GetContractAddressByName(SmartContractConstants.TokenContractSystemName);
}
// Accepted currency is in white list means this token symbol supports voting.
//Length of symbol has been set and unnecessary to set length of AcceptedCurrency.
var isInWhiteList = State.TokenContract.IsInWhiteList.Call(new IsInWhiteListInput
{
Symbol = input.AcceptedCurrency,
Address = Context.Self
}).Value;
Assert(isInWhiteList, "Claimed accepted token is not available for voting.");
// Initialize voting event.
var votingItem = new VotingItem
{
Sponsor = Context.Sender,
VotingItemId = votingItemId,
AcceptedCurrency = input.AcceptedCurrency,
IsLockToken = input.IsLockToken,
TotalSnapshotNumber = input.TotalSnapshotNumber,
CurrentSnapshotNumber = 1,
CurrentSnapshotStartTimestamp = input.StartTimestamp,
StartTimestamp = input.StartTimestamp,
EndTimestamp = input.EndTimestamp,
RegisterTimestamp = Context.CurrentBlockTime,
Options = { input.Options }
};
State.VotingItems[votingItemId] = votingItem;
// Initialize first voting going information of registered voting event.
var votingResultHash = GetVotingResultHash(votingItemId, 1);
State.VotingResults[votingResultHash] = new VotingResult
{
VotingItemId = votingItemId,
SnapshotNumber = 1,
SnapshotStartTimestamp = input.StartTimestamp
};
return(new Empty());
}
public async Task Register_With_Invalid_Timestamp()
{
var endTime = TimestampHelper.GetUtcNow();
var input = new VotingRegisterInput
{
TotalSnapshotNumber = 0,
EndTimestamp = endTime,
StartTimestamp = endTime.AddDays(1),
Options = { GenerateOptions(1) },
AcceptedCurrency = TestTokenSymbol,
IsLockToken = true
};
var transactionResult = (await VoteContractStub.Register.SendWithExceptionAsync(input)).TransactionResult;
transactionResult.Error.ShouldContain("Invalid active time.");
}
/// <summary>
/// Initialize the related contracts=>TokenContract;
/// </summary>
private Hash AssertValidNewVotingItem(VotingRegisterInput input)
{
// Use input without options and sender's address to calculate voting item id.
var votingItemId = input.GetHash(Context.Sender);
Assert(State.VotingItems[votingItemId] == null, "Voting item already exists.");
// total snapshot number can't be 0. At least one epoch is required.
if (input.TotalSnapshotNumber == 0)
{
input.TotalSnapshotNumber = 1;
}
Assert(input.EndTimestamp > input.StartTimestamp, "Invalid active time.");
Context.LogDebug(() => $"Voting item created by {Context.Sender}: {votingItemId.ToHex()}");
return(votingItemId);
}
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();
}
private async Task <TransactionResult> GenerateNewVoteEvent(string topic, int totalEpoch, int activeDays, int optionCount, bool delegated)
{
_options = GenerateOptions(optionCount);
var input = new VotingRegisterInput
{
Topic = topic,
TotalEpoch = totalEpoch,
ActiveDays = activeDays,
StartTimestamp = DateTime.UtcNow.ToTimestamp(),
Options =
{
_options
},
AcceptedCurrency = "ELF",
Delegated = delegated
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
return(transactionResult);
}
public override Empty RegisterElectionVotingEvent(Empty input)
{
Assert(!State.VotingEventRegistered.Value, "Already registered.");
State.VoteContract.Value = Context.GetContractAddressByName(SmartContractConstants.VoteContractSystemName);
var votingRegisterInput = new VotingRegisterInput
{
IsLockToken = false,
AcceptedCurrency = Context.Variables.NativeSymbol,
TotalSnapshotNumber = long.MaxValue,
StartTimestamp = DateTime.MinValue.ToUniversalTime().ToTimestamp(),
EndTimestamp = DateTime.MaxValue.ToUniversalTime().ToTimestamp()
};
State.VoteContract.Register.Send(votingRegisterInput);
State.MinerElectionVotingItemId.Value = Hash.FromTwoHashes(Hash.FromMessage(votingRegisterInput),
Hash.FromMessage(Context.Self));
State.VotingEventRegistered.Value = true;
return(new Empty());
}
/// <summary>
/// Register a voting item.
/// </summary>
/// <param name="lastingDays"></param>
/// <param name="optionsCount"></param>
/// <param name="isLockToken"></param>
/// <param name="sender"></param>
/// <param name="totalSnapshotNumber"></param>
/// <returns></returns>
private async Task <VotingItem> RegisterVotingItemAsync(int lastingDays, int optionsCount, bool isLockToken, Address sender,
int totalSnapshotNumber = int.MaxValue)
{
var startTime = TimestampHelper.GetUtcNow();
var input = new VotingRegisterInput
{
TotalSnapshotNumber = totalSnapshotNumber,
EndTimestamp = startTime.AddDays(lastingDays),
StartTimestamp = startTime,
Options = { GenerateOptions(optionsCount) },
AcceptedCurrency = TestTokenSymbol,
IsLockToken = isLockToken
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
input.Options.Clear();
var votingItemId = Hash.FromTwoHashes(Hash.FromMessage(input), Hash.FromMessage(sender));
return(await VoteContractStub.GetVotingItem.CallAsync(new GetVotingItemInput
{
VotingItemId = votingItemId
}));
}
public async Task VoteContract_RegisterFailed()
{
//invalid topic
{
var input = new VotingRegisterInput
{
Topic = string.Empty,
TotalEpoch = 1
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Topic cannot be null or empty").ShouldBeTrue();
}
//without option
{
var input = new VotingRegisterInput
{
Topic = "test topic",
TotalEpoch = 2,
ActiveDays = 10
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Options cannot be null or empty").ShouldBeTrue();
}
//endless vote event
{
var input = new VotingRegisterInput
{
Topic = "bp election topic",
TotalEpoch = 1,
ActiveDays = int.MaxValue,
Options =
{
Address.Generate().GetFormatted()
}
};
var transactionResult = (await VoteContractStub.Register.SendAsync(input)).TransactionResult;
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Cannot created endless voting event").ShouldBeTrue();
}
//voting with not accepted currency
{
var input = new VotingRegisterInput
{
Topic = "bp election topic",
TotalEpoch = 1,
ActiveDays = 100,
StartTimestamp = DateTime.UtcNow.ToTimestamp(),
AcceptedCurrency = "UTC",
Options =
{
Address.Generate().GetFormatted()
}
};
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 override Empty Register(VotingRegisterInput input)
{
input.Topic = input.Topic.Trim();
if (input.TotalEpoch == 0)
{
input.TotalEpoch = 1;
}
Assert(!string.IsNullOrEmpty(input.Topic), "Topic cannot be null or empty.");
Assert(input.TotalEpoch > 0, "Total epoch number must be greater than 0.");
Assert(input.ActiveDays > 0, "Total active days must be greater than 0.");
Assert(input.Options != null && input.Options.Any(), "Options cannot be null or empty.");
if (input.ActiveDays == int.MaxValue)
{
Assert(input.TotalEpoch != 1, "Cannot created endless voting event.");
}
InitializeDependentContracts();
if (input.StartTimestamp == null || input.StartTimestamp.ToDateTime() < Context.CurrentBlockTime)
{
input.StartTimestamp = Context.CurrentBlockTime.ToTimestamp();
}
var votingEvent = new VotingEvent
{
Sponsor = Context.Sender,
Topic = input.Topic
};
var votingEventHash = votingEvent.GetHash();
Assert(State.VotingEvents[votingEventHash] == null, "Voting event already exists.");
var isInWhiteList = State.TokenContract.IsInWhiteList.Call(new IsInWhiteListInput
{
Symbol = input.AcceptedCurrency,
Address = Context.Self
}).Value;
Assert(isInWhiteList, "Claimed accepted token is not available for voting.");
// Initialize voting event.
votingEvent.AcceptedCurrency = input.AcceptedCurrency;
votingEvent.ActiveDays = input.ActiveDays;
votingEvent.Delegated = input.Delegated;
votingEvent.TotalEpoch = input.TotalEpoch;
votingEvent.Options.AddRange(input.Options);
votingEvent.CurrentEpoch = 1;
votingEvent.EpochStartTimestamp = input.StartTimestamp;
votingEvent.RegisterTimestamp = Context.CurrentBlockTime.ToTimestamp();
votingEvent.StartTimestamp = input.StartTimestamp;
State.VotingEvents[votingEventHash] = votingEvent;
// Initialize first voting going information of registered voting event.
var votingResultHash = Hash.FromMessage(new GetVotingResultInput
{
Sponsor = Context.Sender,
Topic = input.Topic,
EpochNumber = 1
});
State.VotingResults[votingResultHash] = new VotingResult
{
Topic = input.Topic,
Sponsor = Context.Sender,
EpochNumber = 1
};
return(new Empty());
}
