Fix 1244 Mempool.ReverifyTransactions

neo.UnitTests/SmartContract/Native/Tokens/UT_GasToken.cs

@@ -104,22 +104,13 @@ public void Check_BalanceOfTransferAndBurn()
             Assert.ThrowsException<ArgumentOutOfRangeException>(() =>
                 NativeContract.GAS.Burn(engine, new UInt160(to), BigInteger.MinusOne));
 
-            // Burn more than expected
-
-            Assert.ThrowsException<InvalidOperationException>(() =>
-                NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(3000600000000001)));
-
             // Real burn
-
-            NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(1));
+            NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(1)).Should().Be(1);
 
             NativeContract.GAS.BalanceOf(snapshot, to).Should().Be(3000599999999999);
 
-            keyCount.Should().Be(snapshot.Storages.GetChangeSet().Count());
-
-            // Burn all
-
-            NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(3000599999999999));
+            // Burn more than expected
+            NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(3000600000000000)).Should().Be(3000599999999999);
 
             (keyCount - 1).Should().Be(snapshot.Storages.GetChangeSet().Count());
 

neo/SmartContract/Native/Tokens/GasToken.cs

@@ -37,12 +37,25 @@ internal override bool Initialize(ApplicationEngine engine)
         protected override bool OnPersist(ApplicationEngine engine)
         {
             if (!base.OnPersist(engine)) return false;
+            BigInteger totalNetworkFee = 0;
+            BigInteger totalSysFee = 0;
             foreach (Transaction tx in engine.Snapshot.PersistingBlock.Transactions)
-                Burn(engine, tx.Sender, tx.SystemFee + tx.NetworkFee);
+            {
+                BigInteger burned = Burn(engine, tx.Sender, tx.SystemFee + tx.NetworkFee);
+                if (burned >= tx.NetworkFee)
+                {
+                    totalNetworkFee += tx.NetworkFee;
+                    totalSysFee += burned - tx.NetworkFee;
+                }
+                else
+                {
+                    totalNetworkFee += burned;
+                }
+            }
             ECPoint[] validators = NEO.GetNextBlockValidators(engine.Snapshot);
             UInt160 primary = Contract.CreateSignatureRedeemScript(validators[engine.Snapshot.PersistingBlock.ConsensusData.PrimaryIndex]).ToScriptHash();
-            Mint(engine, primary, engine.Snapshot.PersistingBlock.Transactions.Sum(p => p.NetworkFee));
-            BigInteger sys_fee = GetSysFeeAmount(engine.Snapshot, engine.Snapshot.PersistingBlock.Index - 1) + engine.Snapshot.PersistingBlock.Transactions.Sum(p => p.SystemFee);
+            Mint(engine, primary, totalNetworkFee);
+            BigInteger sys_fee = GetSysFeeAmount(engine.Snapshot, engine.Snapshot.PersistingBlock.Index - 1) + totalSysFee;
             StorageKey key = CreateStorageKey(Prefix_SystemFeeAmount, BitConverter.GetBytes(engine.Snapshot.PersistingBlock.Index));
             engine.Snapshot.Storages.Add(key, new StorageItem
             {

neo/SmartContract/Native/Tokens/Nep5Token.cs

@@ -87,15 +87,25 @@ internal protected virtual void Mint(ApplicationEngine engine, UInt160 account,
             engine.SendNotification(Hash, new StackItem[] { "Transfer", StackItem.Null, account.ToArray(), amount });
         }
 
-        internal protected virtual void Burn(ApplicationEngine engine, UInt160 account, BigInteger amount)
+        /// <summary>
+        /// Burn token, when the account balance less than amount, it will burn all the balance of the account
+        /// </summary>
+        /// <param name="engine">The application engine</param>
+        /// <param name="account">The burning account</param>
+        /// <param name="amount">The amount to be burned</param>
+        /// <returns>The actual amount of burned</returns>
+        internal protected virtual BigInteger Burn(ApplicationEngine engine, UInt160 account, BigInteger amount)
         {
             if (amount.Sign < 0) throw new ArgumentOutOfRangeException(nameof(amount));
-            if (amount.IsZero) return;
+            if (amount.IsZero) return amount;
             StorageKey key = CreateAccountKey(account);
             StorageItem storage = engine.Snapshot.Storages.GetAndChange(key);
             TState state = new TState();
             state.FromByteArray(storage.Value);
-            if (state.Balance < amount) throw new InvalidOperationException();
+            if (state.Balance < amount)
+            {
+                amount = state.Balance;
+            }
             OnBalanceChanging(engine, account, state, -amount);
             if (state.Balance == amount)
             {
@@ -111,6 +121,7 @@ internal protected virtual void Burn(ApplicationEngine engine, UInt160 account,
             totalSupply -= amount;
             storage.Value = totalSupply.ToByteArray();
             engine.SendNotification(Hash, new StackItem[] { "Transfer", account.ToArray(), StackItem.Null, amount });
+            return amount;
         }
 
         [ContractMethod(0, ContractParameterType.String, Name = "name", SafeMethod = true)]