Add incentive for voter

src/neo/SmartContract/Native/Tokens/NeoToken.cs

@@ -28,6 +28,7 @@ public sealed class NeoToken : Nep5Token<NeoToken.NeoAccountState>
         private const byte Prefix_Candidate = 33;
         private const byte Prefix_NextValidators = 14;
         private const byte Prefix_GasPerBlock = 29;
+        private const byte Prefix_VoterRewardPerCommittee = 23;
 
         private const byte NeoHolderRewardRatio = 10;
         private const byte CommitteeRewardRatio = 5;
@@ -49,23 +50,49 @@ protected override void OnBalanceChanging(ApplicationEngine engine, UInt160 acco
             if (amount.IsZero) return;
             if (state.VoteTo != null)
             {
-                engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_Candidate).Add(state.VoteTo)).GetInteroperable<CandidateState>().Votes += amount;
+                CandidateState state_validator = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_Candidate).Add(state.VoteTo)).GetInteroperable<CandidateState>();
+                state_validator.Votes += amount;
                 engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_VotersCount)).Add(amount);
+
+                if (state_validator.Votes == 0)
+                {
+                    foreach (var (key, _) in engine.Snapshot.Storages.Find(CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(state.VoteTo).ToArray()))
+                        engine.Snapshot.Storages.Delete(key);
+                }
             }
         }
 
         private void DistributeGas(ApplicationEngine engine, UInt160 account, NeoAccountState state)
         {
-            BigInteger gas = CalculateBonus(engine.Snapshot, state.Balance, state.BalanceHeight, engine.Snapshot.PersistingBlock.Index);
+            BigInteger gas = CalculateBonus(engine.Snapshot, state.VoteTo, state.Balance, state.BalanceHeight, engine.Snapshot.PersistingBlock.Index);
             state.BalanceHeight = engine.Snapshot.PersistingBlock.Index;
             GAS.Mint(engine, account, gas);
         }
 
-        private BigInteger CalculateBonus(StoreView snapshot, BigInteger value, uint start, uint end)
+        private BigInteger CalculateBonus(StoreView snapshot, ECPoint vote, BigInteger value, uint start, uint end)
         {
             if (value.IsZero || start >= end) return BigInteger.Zero;
             if (value.Sign < 0) throw new ArgumentOutOfRangeException(nameof(value));
 
+            BigInteger neoHolderReward = CalculateNeoHolderReward(snapshot, value, start, end);
+            if (vote is null) return neoHolderReward;
+
+            StorageKey keyStart = CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(vote).AddBigEndian(uint.MaxValue - end);
+            StorageKey keyEnd = CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(vote).AddBigEndian(uint.MaxValue - start);
+            IEnumerator<(StorageKey Key, StorageItem Value)> enumerator = snapshot.Storages.FindRange(keyStart, keyEnd).GetEnumerator();
+            if (!enumerator.MoveNext()) return neoHolderReward;
+            var endRewardPerNeo = new BigInteger(enumerator.Current.Value.Value);
+            var startRewardPerNeo = BigInteger.Zero;
+            StorageKey keyMax = CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(vote).AddBigEndian(uint.MaxValue);
+            enumerator = snapshot.Storages.FindRange(keyEnd, keyMax).GetEnumerator();
+            if (enumerator.MoveNext())
+                startRewardPerNeo = new BigInteger(enumerator.Current.Value.Value);
+
+            return neoHolderReward + value * (endRewardPerNeo - startRewardPerNeo) / 10000L;
+        }
+
+        private BigInteger CalculateNeoHolderReward(StoreView snapshot, BigInteger value, uint start, uint end)
+        {
             GasRecord gasRecord = snapshot.Storages[CreateStorageKey(Prefix_GasPerBlock)].GetInteroperable<GasRecord>();
             BigInteger sum = 0;
             for (var i = gasRecord.Count - 1; i >= 0; i--)
@@ -112,6 +139,24 @@ protected override void OnPersist(ApplicationEngine engine)
             var account = Contract.CreateSignatureRedeemScript(pubkey).ToScriptHash();
             GAS.Mint(engine, account, gasPerBlock * CommitteeRewardRatio / 100);
 
+            // Record the cumulative reward of the voters of each committee
+
+            var voterRewardPerCommittee = gasPerBlock * VoterRewardRatio / 100 / (ProtocolSettings.Default.CommitteeMembersCount + ProtocolSettings.Default.ValidatorsCount);
+            var committeeVotes = GetCommitteeVotes(engine.Snapshot).ToArray();
+            for (var i = 0; i < committeeVotes.Length; i++)
+            {
+                if (committeeVotes[i].Votes > 0)
+                {
+                    BigInteger voterSumRewardPerNEO = (i < ProtocolSettings.Default.ValidatorsCount ? 2 : 1) * voterRewardPerCommittee * 10000L / committeeVotes[i].Votes; // Zoom in 10000 times, and the final calculation should be divided 10000L
+                    var voterRewardKeyPrefix = CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(committeeVotes[i].PublicKey);
+                    var enumerator = engine.Snapshot.Storages.Find(voterRewardKeyPrefix.ToArray()).GetEnumerator();
+                    if (enumerator.MoveNext())
+                        voterSumRewardPerNEO += new BigInteger(enumerator.Current.Value.Value);
+                    var voterRewardKey = CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(committeeVotes[i].PublicKey).AddBigEndian(uint.MaxValue - engine.Snapshot.PersistingBlock.Index - 1);
+                    engine.Snapshot.Storages.Add(voterRewardKey, new StorageItem() { Value = voterSumRewardPerNEO.ToByteArray() });
+                }
+            }
+
             // Set next validators
 
             StorageItem storage = engine.Snapshot.Storages.GetAndChange(CreateStorageKey(Prefix_NextValidators), () => new StorageItem());
@@ -152,7 +197,7 @@ public BigInteger UnclaimedGas(StoreView snapshot, UInt160 account, uint end)
             StorageItem storage = snapshot.Storages.TryGet(CreateStorageKey(Prefix_Account).Add(account));
             if (storage is null) return BigInteger.Zero;
             NeoAccountState state = storage.GetInteroperable<NeoAccountState>();
-            return CalculateBonus(snapshot, state.Balance, state.BalanceHeight, end);
+            return CalculateBonus(snapshot, state.VoteTo, state.Balance, state.BalanceHeight, end);
         }
 
         [ContractMethod(0_05000000, CallFlags.AllowModifyStates)]
@@ -211,7 +256,14 @@ private bool Vote(ApplicationEngine engine, UInt160 account, ECPoint voteTo)
                 CandidateState state_validator = storage_validator.GetInteroperable<CandidateState>();
                 state_validator.Votes -= state_account.Balance;
                 if (!state_validator.Registered && state_validator.Votes.IsZero)
+                {
+                    DistributeGas(engine, account, state_account);
+                    UInt160 voteeAddr = Contract.CreateSignatureContract(state_account.VoteTo).ScriptHash;
+                    foreach (var (rewardKey, _) in engine.Snapshot.Storages.Find(CreateStorageKey(Prefix_VoterRewardPerCommittee).Add(voteeAddr).ToArray()))
+                        engine.Snapshot.Storages.Delete(rewardKey);
+
                     engine.Snapshot.Storages.Delete(key);
+                }
             }
             state_account.VoteTo = voteTo;
             if (validator_new != null)
@@ -221,15 +273,29 @@ private bool Vote(ApplicationEngine engine, UInt160 account, ECPoint voteTo)
             return true;
         }
 
+        private CandidateState GetCandidate(StoreView snapshot, ECPoint pubkey)
+        {
+            StorageKey key = CreateStorageKey(Prefix_Candidate).Add(pubkey);
+            return snapshot.Storages.TryGet(key)?.GetInteroperable<CandidateState>();
+        }
+
         [ContractMethod(1_00000000, CallFlags.AllowStates)]
         public (ECPoint PublicKey, BigInteger Votes)[] GetCandidates(StoreView snapshot)
+        {
+            return GetCandidatesInternal(snapshot)
+                .Where(p => p.State.Registered)
+                .Select(p => (p.PublicKey, p.State.Votes))
+                .ToArray();
+        }
+
+        private IEnumerable<(ECPoint PublicKey, CandidateState State)> GetCandidatesInternal(StoreView snapshot)
         {
             byte[] prefix_key = CreateStorageKey(Prefix_Candidate).ToArray();
             return snapshot.Storages.Find(prefix_key).Select(p =>
             (
                 p.Key.Key.AsSerializable<ECPoint>(1),
                 p.Value.GetInteroperable<CandidateState>()
-            )).Where(p => p.Item2.Registered).Select(p => (p.Item1, p.Item2.Votes)).ToArray();
+            ));
         }
 
         [ContractMethod(1_00000000, CallFlags.AllowStates)]
@@ -262,6 +328,24 @@ private IEnumerable<ECPoint> GetCommitteeMembers(StoreView snapshot)
             return candidates.OrderByDescending(p => p.Votes).ThenBy(p => p.PublicKey).Select(p => p.PublicKey).Take(ProtocolSettings.Default.CommitteeMembersCount);
         }
 
+        private IEnumerable<(ECPoint PublicKey, BigInteger Votes)> GetCommitteeVotes(StoreView snapshot)
+        {
+            decimal votersCount = (decimal)(BigInteger)snapshot.Storages[CreateStorageKey(Prefix_VotersCount)];
+            decimal VoterTurnout = votersCount / (decimal)TotalAmount;
+            if (VoterTurnout < EffectiveVoterTurnout)
+                return Blockchain.StandbyCommittee.Select(p => (p, GetCandidate(snapshot, p)?.Votes ?? BigInteger.Zero));
+            var candidates = GetCandidatesInternal(snapshot).ToDictionary(p => p.PublicKey, p => p.State);
+            if (candidates.Count(p => p.Value.Registered) < ProtocolSettings.Default.CommitteeMembersCount)
+                return Blockchain.StandbyCommittee.Select(p =>
+                {
+                    if (candidates.TryGetValue(p, out CandidateState candidate))
+                        return (p, candidate.Votes);
+                    else
+                        return (p, BigInteger.Zero);
+                });
+            return candidates.OrderByDescending(p => p.Value.Votes).ThenBy(p => p.Key).Select(p => (p.Key, p.Value.Votes)).Take(ProtocolSettings.Default.CommitteeMembersCount);
+        }
+
         [ContractMethod(1_00000000, CallFlags.AllowStates)]
         public ECPoint[] GetNextBlockValidators(StoreView snapshot)
         {

tests/neo.UnitTests/SmartContract/Native/Tokens/UT_NeoToken.cs

@@ -1,5 +1,6 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Neo.Consensus;
 using Neo.Cryptography;
 using Neo.Cryptography.ECC;
 using Neo.IO;
@@ -11,6 +12,7 @@
 using Neo.SmartContract.Native;
 using Neo.UnitTests.Extensions;
 using Neo.VM;
+using Neo.Wallets;
 using System;
 using System.Linq;
 using System.Numerics;
@@ -460,6 +462,16 @@ public void TestCalculateBonus()
             action = () => NativeContract.NEO.UnclaimedGas(snapshot, UInt160.Zero, 10).Should().Be(new BigInteger(0));
             snapshot.Storages.Delete(key);
 
+            // Fault range: start >= end
+
+            snapshot.Storages.GetAndChange(key, () => new StorageItem(new NeoAccountState
+            {
+                Balance = 100,
+                BalanceHeight = 100
+            }));
+            action = () => NativeContract.NEO.UnclaimedGas(snapshot, UInt160.Zero, 10).Should().Be(new BigInteger(0));
+            snapshot.Storages.Delete(key);
+
             // Normal 1) votee is non exist
 
             snapshot.Storages.GetAndChange(key, () => new StorageItem(new NeoAccountState
@@ -468,6 +480,27 @@ public void TestCalculateBonus()
             }));
             NativeContract.NEO.UnclaimedGas(snapshot, UInt160.Zero, 100).Should().Be(new BigInteger(0.5 * 100 * 100));
             snapshot.Storages.Delete(key);
+
+            // Normal 2) votee is not committee
+
+            snapshot.Storages.GetAndChange(key, () => new StorageItem(new NeoAccountState
+            {
+                Balance = 100,
+                VoteTo = ECCurve.Secp256r1.G
+            }));
+            NativeContract.NEO.UnclaimedGas(snapshot, UInt160.Zero, 100).Should().Be(new BigInteger(0.5 * 100 * 100));
+            snapshot.Storages.Delete(key);
+
+            // Normal 3) votee is committee
+
+            snapshot.Storages.GetAndChange(key, () => new StorageItem(new NeoAccountState
+            {
+                Balance = 100,
+                VoteTo = Blockchain.StandbyCommittee[0]
+            }));
+            snapshot.Storages.Add(new KeyBuilder(-1, 23).Add(Blockchain.StandbyCommittee[0]).AddBigEndian(uint.MaxValue - 50), new StorageItem() { Value = new BigInteger(50 * 10000L).ToByteArray() });
+            NativeContract.NEO.UnclaimedGas(snapshot, UInt160.Zero, 100).Should().Be(new BigInteger(100 * 100));
+            snapshot.Storages.Delete(key);
         }
 
         [TestMethod]
@@ -602,6 +635,82 @@ public void TestEconomicParameter()
             result1.Item1.GetBoolean().Should().BeTrue();
         }
 
+        [TestMethod]
+        public void TestClaimGas()
+        {
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+
+            // Initialize block
+
+            for (var i = 0; i < ProtocolSettings.Default.CommitteeMembersCount; i++)
+            {
+                ECPoint member = Blockchain.StandbyCommittee[i];
+                var moreVotes = 0;
+                if (i < ProtocolSettings.Default.ValidatorsCount)
+                    moreVotes += 10;
+                snapshot.Storages.Add(new KeyBuilder(-1, 33).Add(member), new StorageItem(new CandidateState()
+                {
+                    Registered = true,
+                    Votes = 100 * 10000 + moreVotes
+                }));
+            }
+            var item = snapshot.Storages.GetAndChange(new KeyBuilder(-1, 1), () => new StorageItem());
+            item.Value = ((BigInteger)2100 * 10000L).ToByteArray();
+
+            snapshot.PersistingBlock = new Block { Index = 0 };
+            Check_OnPersist(snapshot).Should().BeTrue();
+
+            for (var i = 0; i < ProtocolSettings.Default.CommitteeMembersCount; i++)
+            {
+                ECPoint member = Blockchain.StandbyCommittee[i];
+                StorageItem storageItem = snapshot.Storages.TryGet(new KeyBuilder(-1, 23).Add(member).AddBigEndian(uint.MaxValue - 1));
+                if (i < ProtocolSettings.Default.ValidatorsCount)
+                    new BigInteger(storageItem.Value).Should().Be(303568);
+                else
+                    new BigInteger(storageItem.Value).Should().Be(151785);
+            }
+
+            // Next block
+
+            snapshot.PersistingBlock = new Block { Index = 1 };
+            Check_OnPersist(snapshot).Should().BeTrue();
+            for (var i = 0; i < ProtocolSettings.Default.CommitteeMembersCount; i++)
+            {
+                ECPoint member = Blockchain.StandbyCommittee[i];
+                StorageItem storageItem = snapshot.Storages.TryGet(new KeyBuilder(-1, 23).Add(member).AddBigEndian(uint.MaxValue - 1 - 1));
+                if (i < ProtocolSettings.Default.ValidatorsCount)
+                    new BigInteger(storageItem.Value).Should().Be(303568 * 2);
+                else
+                    new BigInteger(storageItem.Value).Should().Be(151785 * 2);
+            }
+
+            // Next block
+
+            snapshot.PersistingBlock = new Block { Index = 2 };
+            Check_OnPersist(snapshot).Should().BeTrue();
+            for (var i = 0; i < ProtocolSettings.Default.CommitteeMembersCount; i++)
+            {
+                ECPoint member = Blockchain.StandbyCommittee[i];
+                StorageItem storageItem = snapshot.Storages.TryGet(new KeyBuilder(-1, 23).Add(member).AddBigEndian(uint.MaxValue - 1 - 2));
+                if (i < ProtocolSettings.Default.ValidatorsCount)
+                    new BigInteger(storageItem.Value).Should().Be(303568 * 3);
+                else
+                    new BigInteger(storageItem.Value).Should().Be(151785 * 3);
+            }
+
+            // Claim GAS
+
+            var account = Contract.CreateSignatureContract(Blockchain.StandbyCommittee[0]).ScriptHash;
+            snapshot.Storages.Add(new KeyBuilder(-1, 20).Add(account), new StorageItem(new NeoAccountState
+            {
+                BalanceHeight = 1,
+                Balance = 100,
+                VoteTo = Blockchain.StandbyCommittee[0]
+            }));
+            BigInteger value = NativeContract.NEO.UnclaimedGas(snapshot, account, 2);
+            value.Should().Be(3085);
+        }
+
         [TestMethod]
         public void TestUnclaimedGas()
         {
@@ -675,6 +784,24 @@ public void TestVote()
             return (true, result.GetBoolean());
         }
 
+        internal static bool Check_OnPersist(StoreView snapshot)
+        {
+            ECPoint[] committees = NativeContract.NEO.GetCommittee(snapshot);
+            UInt160 committeesMultisign = Contract.CreateMultiSigRedeemScript(committees.Length - (committees.Length - 1) / 2, committees).ToScriptHash();
+            var engine = ApplicationEngine.Create(TriggerType.System,
+                new Nep5NativeContractExtensions.ManualWitness(committeesMultisign), snapshot);
+
+            engine.LoadScript(NativeContract.NEO.Script);
+
+            var script = new ScriptBuilder();
+            script.EmitPush(0);
+            script.Emit(OpCode.PACK);
+            script.EmitPush("onPersist");
+            engine.LoadScript(script.ToArray());
+
+            return engine.Execute() == VMState.HALT;
+        }
+
         internal static (BigInteger Value, bool State) Check_GetGasPerBlock(StoreView snapshot)
         {
             var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot);