/// <summary>
/// allow an administrator to request the unlocking of founder tokens
/// </summary>
/// <param name="address">founders script hash</param>
/// <param name="roundNumber">1-7</param>
/// <returns></returns>
public static bool UnlockFoundersTokens(byte[] address, int roundNumber)
{
if (address.Length != 20)
{
Runtime.Log("UnlockFoundersTokens() invalid address supplied");
return(false);
}
byte[] roundKey = address.Concat(((BigInteger)roundNumber).AsByteArray());
StorageMap unlockedRounds = Storage.CurrentContext.CreateMap(StorageKeys.FounderTokenUnlockRound());
bool roundPreviouslyUnlocked = unlockedRounds.Get(roundKey).AsBigInteger() > 0;
if (roundPreviouslyUnlocked)
{
Runtime.Log("UnlockFoundersTokens() round already unlocked");
return(false);
}
object[] foundersVestingPeriod = GetCoreTeamVestingSchedule();
uint currentTimestamp = Helpers.GetBlockTimestamp();
int roundIndex = (roundNumber * 2) - 2;
int roundValueIndex = roundIndex + 1;
if (roundIndex < 0)
{
Runtime.Log("UnlockFoundersTokens() invalid round index (<0)");
return(false);
}
uint roundReleaseDate = (uint)foundersVestingPeriod[roundIndex];
BigInteger roundReleaseAmount = (BigInteger)foundersVestingPeriod[roundValueIndex];
if (currentTimestamp < roundReleaseDate)
{
Runtime.Log("UnlockFoundersTokens() not scheduled for release");
return(false);
}
object[] founderKeys = ICOContract.MoonlightFounderKeys();
for (int i = 0; i < founderKeys.Length; i++)
{
byte[] founderKey = (byte[])founderKeys[i];
if (founderKey == address)
{
Runtime.Notify("UnlockFoundersTokens() releasing funds. currentTimestamp / roundReleaseDate / roundReleaseAmount", currentTimestamp, roundReleaseDate, roundReleaseAmount);
Helpers.SetBalanceOf(founderKey, NEP5.BalanceOf(founderKey) + roundReleaseAmount); // set new balance for destination account
unlockedRounds.Put(roundKey, "1");
return(true);
}
}
return(false);
}
/// <summary>
/// determine if address is one of the founder keys or the ML project key. if so they are still subject to vesting rules
/// </summary>
/// <param name="address"></param>
/// <returns>bool</returns>
public static bool IsProjectKey(byte[] address)
{
object[] keys = ICOContract.MoonlightFounderKeys();
if (address == (byte[])keys[0] || address == (byte[])keys[1] || address == (byte[])keys[2] ||
address == (byte[])keys[3] || address == (byte[])keys[4] || address == ICOContract.MoonlightProjectKey())
{
return(true);
}
return(false);
}
/// <summary>
/// get the maximum number of LX that can be purchased by groupNumber during the public sale
/// </summary>
/// <param name="groupNumber"></param>
/// <returns></returns>
public static BigInteger GetGroupMaxContribution(BigInteger groupNumber)
{
StorageMap contributionLimits = Storage.CurrentContext.CreateMap(StorageKeys.GroupContributionAmountPrefix());
BigInteger maxContribution = contributionLimits.Get(groupNumber.AsByteArray()).AsBigInteger();
if (maxContribution > 0)
{
return(maxContribution);
}
return(ICOContract.MaximumContributionAmount());
}
/// <summary>
/// initialise the smart contract for use
/// </summary>
/// <returns></returns>
public static bool InitSmartContract()
{
if (Helpers.ContractInitialised())
{
// contract can only be initialised once
Runtime.Log("InitSmartContract() contract already initialised");
return(false);
}
uint ContractInitTime = Helpers.GetBlockTimestamp();
Storage.Put(Storage.CurrentContext, StorageKeys.ContractInitTime(), ContractInitTime);
// assign pre-allocated tokens to the project
object[] immediateAllocation = ICOContract.ImmediateProjectGrowthAllocation();
object[] vestedAllocation = ICOContract.VestedProjectGrowthAllocation();
BigInteger immediateProjectAllocationValue = ((ICOContract.TokenMaxSupply * (BigInteger)immediateAllocation[0]) / 100) * NEP5.factor;
BigInteger vestedProjectAllocationValue = ((ICOContract.TokenMaxSupply * (BigInteger)vestedAllocation[0]) / 100) * NEP5.factor;
Helpers.SetBalanceOf(ICOContract.MoonlightProjectKey(), immediateProjectAllocationValue + vestedProjectAllocationValue);
Helpers.SetBalanceOfVestedAmount(ICOContract.MoonlightProjectKey(), immediateProjectAllocationValue + vestedProjectAllocationValue);
// lockup a portion of the tokens to be released in the future
uint vestedGrowthReleaseDate = (uint)vestedAllocation[1] + ContractInitTime;
object[] vestedTokenPeriod = new object[] { vestedGrowthReleaseDate, vestedProjectAllocationValue };
StorageMap vestingData = Storage.CurrentContext.CreateMap(StorageKeys.VestedTokenPrefix());
vestingData.Put(ICOContract.MoonlightProjectKey(), vestedTokenPeriod.Serialize());
// token allocation to MoonlightFounderKeys - update the total supply to include balance - these funds will be unlocked gradually
BigInteger founderTokenAllocation = ((ICOContract.TokenMaxSupply * (BigInteger)ICOContract.MoonlightFoundersAllocationPercentage()) / 100) * NEP5.factor;
// token allocated to presale
BigInteger presaleAllocationMaxValue = ((ICOContract.TokenMaxSupply * (BigInteger)ICOContract.PresaleAllocationPercentage()) / 100) * NEP5.factor;
// update the total supply to reflect the project allocated tokens
BigInteger totalSupply = immediateProjectAllocationValue + vestedProjectAllocationValue + founderTokenAllocation + presaleAllocationMaxValue;
Helpers.SetTotalSupply(totalSupply);
UpdateAdminAddress(ICOContract.InitialAdminAccount);
EnableDEXWhitelisting(ICOContract.WhitelistDEXListings());
Runtime.Log("InitSmartContract() contract initialisation complete");
return(true);
}
/// <summary>
/// set a vesting schedule, as defined in the whitepaper, for tokens purchased during the presale
/// </summary>
/// <param name="address"></param>
/// <param name="tokenBalance"></param>
/// <returns></returns>
public static bool SetVestingPeriodForAddress(byte[] address, BigInteger tokensPurchased)
{
if (!ICOContract.UseTokenVestingPeriod())
{
return(false);
}
if (address.Length != 20)
{
return(false);
}
object[] vestingOne = ICOContract.VestingBracketOne();
object[] vestingTwo = ICOContract.VestingBracketTwo();
BigInteger bracketOneThreshold = (BigInteger)vestingOne[0] * NEP5.factor;
BigInteger bracketTwoThreshold = (BigInteger)vestingTwo[0] * NEP5.factor;
BigInteger currentAvailableBalance = 0; // how many tokens will be immediately available to the owner
uint currentTimestamp = Helpers.GetContractInitTime();
uint bracketOneReleaseDate = (uint)vestingOne[1] + currentTimestamp;
uint bracketTwoReleaseDate = (uint)vestingTwo[1] + currentTimestamp;
StorageMap vestingData = Storage.CurrentContext.CreateMap(StorageKeys.VestedTokenPrefix());
if (tokensPurchased > bracketTwoThreshold)
{
// user has purchased enough tokens to fall under the second vesting period restriction
// calculate the difference between the bracketOne and bracketTwo thresholds to calculate how much should be released after bracketOne lapses
BigInteger bracketOneReleaseAmount = bracketTwoThreshold - bracketOneThreshold;
// the remainder will be released after the bracket two release date
BigInteger bracketTwoReleaseAmount = tokensPurchased - bracketOneReleaseAmount - bracketOneThreshold;
object[] lockoutTimes = new object[] { bracketOneReleaseDate, bracketOneReleaseAmount, bracketTwoReleaseDate, bracketTwoReleaseAmount };
vestingData.Put(address, lockoutTimes.Serialize());
}
else
{
// user has purchased enough tokens to fall under the first vesting period restriction
// calculate the difference between amount purchased and bracketOne threshold to calculate how much should be released after the bracketOne lapses
BigInteger bracketOneReleaseAmount = tokensPurchased - bracketOneThreshold;
object[] lockoutTimes = new object[] { bracketOneReleaseDate, bracketOneReleaseAmount };
vestingData.Put(address, lockoutTimes.Serialize());
}
// ensure the total amount purchased is saved
Helpers.SetBalanceOf(address, tokensPurchased);
Helpers.SetBalanceOfVestedAmount(address, tokensPurchased);
return(true);
}
public static object HandleHelperOperation(string operation, params object[] args)
{
switch (operation)
{
case "BalanceOfVestedAddress":
// retrieve the real balance of an address that has been subjected to whitepaper defined vesting period
if (!Helpers.RequireArgumentLength(args, 1))
{
return(false);
}
return(Helpers.BalanceOfVestedAddress((byte[])args[0]));
case "IsPresaleAllocationLocked":
// if the admin method `Administration.AllocatePresalePurchase` is permanently disabled, this method will return
// the timestamp the lock was put in place.
return(Storage.Get(Storage.CurrentContext, StorageKeys.PresaleAllocationLocked()));
case "supportedStandards":
// support NEP-10 by responding to supportedStandards
// https://github.com/neo-project/proposals/blob/master/nep-10.mediawiki
return(ICOContract.SupportedStandards());
}
return(false);
}
/// <summary>
/// the core teams token allocation follow a linear quarterly maturation over 18 months beginning after 6 months
/// </summary>
/// <returns></returns>
public static object[] GetCoreTeamVestingSchedule()
{
// calculate the allocation given to each team member
object[] founderKeys = ICOContract.MoonlightFounderKeys();
BigInteger founderTokenAllocation = ((ICOContract.TokenMaxSupply * (BigInteger)ICOContract.MoonlightFoundersAllocationPercentage()) / 100) * NEP5.factor;
BigInteger individualAllocation = founderTokenAllocation / founderKeys.Length;
uint ContractInitTime = Helpers.GetContractInitTime();
// determine vesting schedule details for core teams token allocation
// there will be 7 releases, one each quarter ending 2 years from contract init
int numberOfTokenReleases = 7;
BigInteger tokensPerRelease = individualAllocation / numberOfTokenReleases;
object[] vestingPeriod = new object[14];
object[] founderReleaseSchedule = ICOContract.MoonlightFoundersAllocationReleaseSchedule();
uint initialReleaseDate = ContractInitTime + (uint)founderReleaseSchedule[0];
uint releaseFrequency = (uint)founderReleaseSchedule[1];
BigInteger tokensReleased = tokensPerRelease;
// this is not the nicest way to populate the vesting schedule array, but it is much cheaper (in terms of processing/gas price) than looping
vestingPeriod[0] = initialReleaseDate;
vestingPeriod[1] = tokensPerRelease;
// 3 months later release another batch of tokens
tokensReleased += tokensPerRelease;
vestingPeriod[2] = initialReleaseDate + (releaseFrequency * 1);
vestingPeriod[3] = tokensPerRelease;
// 3 months later release another batch of tokens
tokensReleased += tokensPerRelease;
vestingPeriod[4] = initialReleaseDate + (releaseFrequency * 2);
vestingPeriod[5] = tokensPerRelease;
// 3 months later release another batch of tokens
tokensReleased += tokensPerRelease;
vestingPeriod[6] = initialReleaseDate + (releaseFrequency * 3);
vestingPeriod[7] = tokensPerRelease;
// 3 months later release another batch of tokens
tokensReleased += tokensPerRelease;
vestingPeriod[8] = initialReleaseDate + (releaseFrequency * 4);
vestingPeriod[9] = tokensPerRelease;
// 3 months later release another batch of tokens
tokensReleased += tokensPerRelease;
vestingPeriod[10] = initialReleaseDate + (releaseFrequency * 5);
vestingPeriod[11] = tokensPerRelease;
// 3 months later release the last of the tokens
vestingPeriod[12] = initialReleaseDate + (releaseFrequency * 6);
vestingPeriod[13] = individualAllocation - tokensReleased;
/*
* Runtime.Notify("VestingSchedule", Helpers.SerializeArray(vestingPeriod));
* a serialised copy of this array ends up with values such as (dates subject to change):
* 0e
* 04 292cf05b 5bf02c29 1542466601 Saturday, November 17, 2018 2:56:41 PM
* 07 6ddb810adb0301 0103db0a81db6d 285714285714285
* 04 0979685c 5c687909 1550350601 Saturday, February 16, 2019 8:56:41 PM
* 07 dab60315b60702 0207b61503b6da 571428571428570
* 04 e9c5e05c 5ce0c5e9 1558234601 Sunday, May 19, 2019 2:56:41 AM
* 07 4792851f910b03 030b911f859247 857142857142855
* 04 c912595d 5d5912c9 1566118601 Sunday, August 18, 2019 8:56:41 AM
* 07 b46d072a6c0f04 040f6c2a076db4 1142857142857140
* 04 a95fd15d 5dd15fa9 1574002601 Sunday, November 17, 2019 2:56:41 PM
* 07 21498934471305 05134734894921 1428571428571425
* 04 89ac495e 5e49ac89 1581886601 Sunday, February 16, 2020 8:56:41 PM
* 07 8e240b3f221706 0617223f0b248e 1714285714285710
* 04 69f9c15e 5ec1f969 1589770601 Monday, May 18, 2020 2:56:41 AM
* 07 00008d49fd1a07 071afd498d0000 2000000000000000
*/
return(vestingPeriod);
}
/// <summary>
/// allow allocation of presale purchases by contract administrator. this allows the moonlight team to allocate the 25% of LX tokens sold in the private presale.
/// as we accepted ETH in addition to NEO&GAS, using a mintTokens method here is not practical.
/// 1. this method will not allow the presale allocation to exceed the defined amount
/// 2. this method is permanently disabled once the method `LockPresaleAllocation` has been called.
/// 3. the state of the `LockPresaleAllocation` can be determined by the public using the method `IsPresaleAllocationLocked` (returns timestamp that lock was put in place)
/// </summary>
/// <param name="address"></param>
/// <param name="amountPurchased"></param>
/// <returns></returns>
public static bool AllocatePresalePurchase(byte[] address, BigInteger amountPurchased)
{
bool presaleLocked = Storage.Get(Storage.CurrentContext, StorageKeys.PresaleAllocationLocked()).AsBigInteger() > 0;
if (presaleLocked)
{
Runtime.Notify("AllocatePresalePurchase() presaleLocked, can't allocate");
return(false);
}
BigInteger presaleAllocationMaxValue = ((ICOContract.TokenMaxSupply * (BigInteger)ICOContract.PresaleAllocationPercentage()) / 100) * NEP5.factor;
BigInteger presaleAllocatedValue = Storage.Get(Storage.CurrentContext, StorageKeys.PresaleAllocatedValue()).AsBigInteger();
if ((presaleAllocatedValue + amountPurchased) > presaleAllocationMaxValue)
{
// this purchase will exceed the presale cap.. dont allow
Runtime.Notify("AllocatePresalePurchase() purchase will exceed presale max allocation");
return(false);
}
TokenSale.SetVestingPeriodForAddress(address, amountPurchased);
Storage.Put(Storage.CurrentContext, StorageKeys.PresaleAllocatedValue(), presaleAllocatedValue + amountPurchased);
Runtime.Notify("AllocatePresalePurchase() tokens allocated", address, amountPurchased);
return(true);
}
public static object HandleNEP5Operation(string operation, object[] args, byte[] caller, byte[] entry)
{
//{ "name", "symbol", "decimals", "totalSupply", "balanceOf", "transfer", "transferFrom", "approve", "allowance" };
if (operation == "name")
{
// the name of the token
return(ICOContract.TokenName());
}
if (operation == "symbol")
{
// the symbol of the token
return(ICOContract.TokenSymbol());
}
if (operation == "decimals")
{
// decimals to determine fractions of tokens
return(TokenDecimals());
}
if (operation == "totalSupply")
{
// the total number of tokens minted
return(TotalSupply());
}
if (operation == "balanceOf")
{
// retreive the balance of an address
if (!Helpers.RequireArgumentLength(args, 1))
{
// BalanceOf() requires at least 1 argument - the address to check the balance of
return(false);
}
return(BalanceOf((byte[])args[0]));
}
if (operation == "transfer")
{
// transfer tokens from one address to another
if (!Helpers.RequireArgumentLength(args, 3))
{
// Transfer() requires 3 arguments: from, to, amount
return(false);
}
return(Transfer((byte[])args[0], (byte[])args[1], (BigInteger)args[2], caller, entry));
}
if (operation == "transferFrom")
{
// transfer tokens from one address to another
if (!Helpers.RequireArgumentLength(args, 4))
{
// TransferFrom() requires 4 arguments: originator, from, to, amount
return(false);
}
return(TransferFrom((byte[])args[0], (byte[])args[1], (byte[])args[2], (BigInteger)args[3], caller, entry));
}
if (operation == "approve")
{
// approve a third party to transfer tokens from one address to another
if (!Helpers.RequireArgumentLength(args, 3))
{
// Approve() requires 3 arguments: originator, to, amount
return(false);
}
return(Approve((byte[])args[0], (byte[])args[1], (BigInteger)args[2], caller, entry));
}
if (operation == "allowance")
{
// retreive the authorised balance of an address
if (!Helpers.RequireArgumentLength(args, 2))
{
// Allowance() requires 2 arguments: from, to
return(false);
}
return(Allowance((byte[])args[0], (byte[])args[1]));
}
// check how many tokens left for purchase
if (operation == "crowdsale_available_amount")
{
return(CrowdsaleAvailableAmount());
}
if (operation == "mintTokens")
{
return(TokenSale.MintTokens());
}
return(false);
}
/// <summary>
/// retrieve information for the received transaction
/// </summary>
/// <returns>object[] {
/// (Transaction)tx, (byte[])sender, (byte)receiver, ulong receivedNEO, ulong receivedGAS,
/// (BigInteger)whiteListGroupNumber, (BigInteger)crowdsaleAvailableAmount, (BigInteger)groupMaximumContribution
/// (BigInteger)totalTokensPurchased, (BigInteger)neoRemainingAfterPurchase, (BigInteger)gasRemainingAfterPurchase
/// (BigInteger)totalContributionBalance
/// }
/// </returns>
public static object[] GetTransactionAndSaleData()
{
Transaction tx = (Transaction)ExecutionEngine.ScriptContainer;
TransactionOutput[] inputs = tx.GetReferences();
TransactionOutput reference = inputs[0];
TransactionOutput[] outputs = tx.GetOutputs();
byte[] sender = reference.ScriptHash;
byte[] receiver = ExecutionEngine.ExecutingScriptHash;
ulong receivedNEO = 0;
ulong receivedGAS = 0;
foreach (var input in inputs)
{
// ensure that the provided inputs are valid
if (input.ScriptHash == receiver)
{
throw new System.Exception();
}
}
foreach (TransactionOutput output in outputs)
{
if (output.ScriptHash == receiver)
{
// only add funds to total received value if receiver is the recipient of the output
ulong receivedValue = (ulong)output.Value;
Runtime.Notify("GetTransactionData() Received Deposit type", receiver, reference.AssetId);
if (reference.AssetId == NEP5.NEO)
{
receivedNEO += receivedValue;
}
else if (reference.AssetId == NEP5.GAS)
{
receivedGAS += receivedValue;
}
}
}
BigInteger whiteListGroupNumber = KYC.GetWhitelistGroupNumber(sender);
BigInteger crowdsaleAvailableAmount = NEP5.CrowdsaleAvailableAmount();
BigInteger groupMaximumContribution = KYC.GetGroupMaxContribution(whiteListGroupNumber) * NEP5.factor;
BigInteger totalTokensPurchased = 0;
BigInteger neoRemainingAfterPurchase = 0;
BigInteger gasRemainingAfterPurchase = 0;
BigInteger runningCrowdsaleAmount = crowdsaleAvailableAmount;
if (ICOContract.ICOAllowsNEO() && receivedNEO > 0)
{
BigInteger neoTokenValue = receivedNEO * ICOContract.ICONeoToTokenExchangeRate();
if (neoTokenValue > runningCrowdsaleAmount)
{
// the user is trying to purchase more tokens than are available
// figure out how much LX can be purchased without exceeding the cap
neoRemainingAfterPurchase = (neoTokenValue - runningCrowdsaleAmount) / (ICOContract.ICONeoToTokenExchangeRate());
totalTokensPurchased = runningCrowdsaleAmount;
}
else
{
// there is enough LX left for this purchase to complete
totalTokensPurchased = neoTokenValue;
}
// ensure amountAvailable now reflects number of tokens purchased with NEO
runningCrowdsaleAmount -= totalTokensPurchased;
}
if (ICOContract.ICOAllowsGAS() && receivedGAS > 0)
{
BigInteger gasTokenValue = receivedGAS * ICOContract.ICOGasToTokenExchangeRate();
if (gasTokenValue > runningCrowdsaleAmount)
{
// the user is trying to purchase more tokens than are available
// figure out how much LX can be purchased without exceeding the cap
gasRemainingAfterPurchase = (gasTokenValue - runningCrowdsaleAmount) / (ICOContract.ICOGasToTokenExchangeRate());
totalTokensPurchased = totalTokensPurchased + runningCrowdsaleAmount;
}
else
{
totalTokensPurchased = totalTokensPurchased + gasTokenValue;
}
}
BigInteger totalContributionBalance = BalanceOfSaleContribution(sender) + totalTokensPurchased;
return(new object[] {
tx, // neo transaction object
sender, // who initiated the transfer
receiver, // who the assets were sent to
receivedNEO, // how many neo were transferred
receivedGAS, // how many gas were transferred
whiteListGroupNumber, // what whitelist group is the sender in
crowdsaleAvailableAmount, // how many tokens are left to be purchased
groupMaximumContribution, // how many tokens can members of this whitelist group purchase
totalTokensPurchased, // the total number of tokens purchased in this transaction
neoRemainingAfterPurchase, // how much neo is left after purchase of tokens
gasRemainingAfterPurchase, // how much gas is left after purchase of tokens
totalContributionBalance // the total amount of tokens sender has purchased during public sale
});
}