Adjust the Charge for Storage Writting

src/neo/IO/Caching/DataCache.cs

@@ -285,7 +285,7 @@ public TValue GetOrAdd(TKey key, Func<TValue> factory)
             }
         }
 
-        public TValue TryGet(TKey key)
+        public virtual TValue TryGet(TKey key)
         {
             lock (dictionary)
             {

src/neo/Ledger/Blockchain.cs

@@ -286,7 +286,6 @@ private void OnFillMemoryPool(IEnumerable<Transaction> transactions)
                 MemPool.TryAdd(tx.Hash, tx);
             }
             // Transactions originally in the pool will automatically be reverified based on their priority.
-
             Sender.Tell(new FillCompleted());
         }
 
@@ -493,6 +492,7 @@ private void Persist(Block block)
             using (SnapshotView snapshot = GetSnapshot())
             {
                 List<ApplicationExecuted> all_application_executed = new List<ApplicationExecuted>();
+                List<Tuple<Transaction, long>> recycleRewardGasTxs = new List<Tuple<Transaction, long>>();
                 snapshot.PersistingBlock = block;
                 if (block.Index > 0)
                 {
@@ -522,13 +522,16 @@ private void Persist(Block block)
                         state.VMState = engine.Execute();
                         if (state.VMState == VMState.HALT)
                         {
+                            if (engine.RecyclingRewardGas > 0)
+                                recycleRewardGasTxs.Add(new Tuple<Transaction, long>(tx, engine.RecyclingRewardGas));
                             engine.Snapshot.Commit();
                         }
                         ApplicationExecuted application_executed = new ApplicationExecuted(engine);
                         Context.System.EventStream.Publish(application_executed);
                         all_application_executed.Add(application_executed);
                     }
                 }
+                RecycleRewardGas(snapshot, all_application_executed, recycleRewardGasTxs);
                 snapshot.BlockHashIndex.GetAndChange().Set(block);
                 if (block.Index == header_index.Count)
                 {
@@ -562,6 +565,30 @@ private void Persist(Block block)
             OnPersistCompleted(block);
         }
 
+        private void RecycleRewardGas(SnapshotView snapshot, List<ApplicationExecuted> all_application_executed, List<Tuple<Transaction, long>> recycleRewardGasTxs)
+        {
+            foreach (var tuple in recycleRewardGasTxs)
+            {
+                var tx = tuple.Item1;
+                var recycleRewardGas = tuple.Item2;
+                Script onRecycleRewardGasScript = null;
+                using (ScriptBuilder sb = new ScriptBuilder())
+                {
+                    sb.EmitAppCall(NativeContract.GAS.Hash, "onRecycleRewardGas", tx.Sender, recycleRewardGas);
+                    sb.Emit(OpCode.THROWIFNOT);
+                    onRecycleRewardGasScript = sb.ToArray();
+                }
+                using (ApplicationEngine engine = new ApplicationEngine(TriggerType.System, null, snapshot, 0, true))
+                {
+                    engine.LoadScript(onRecycleRewardGasScript);
+                    if (engine.Execute() != VMState.HALT) throw new InvalidOperationException();
+                    ApplicationExecuted application_executed = new ApplicationExecuted(engine);
+                    Context.System.EventStream.Publish(application_executed);
+                    all_application_executed.Add(application_executed);
+                }
+            }
+        }
+
         protected override void PostStop()
         {
             base.PostStop();

src/neo/SmartContract/ApplicationEngine.cs

@@ -20,11 +20,17 @@ public partial class ApplicationEngine : ExecutionEngine
         private readonly bool testMode;
         private readonly List<NotifyEventArgs> notifications = new List<NotifyEventArgs>();
         private readonly List<IDisposable> disposables = new List<IDisposable>();
+        private readonly List<StorageKey> updatedKeys = new List<StorageKey>();
 
         public TriggerType Trigger { get; }
         public IVerifiable ScriptContainer { get; }
         public StoreView Snapshot { get; }
         public long GasConsumed { get; private set; } = 0;
+
+        /// <summary>
+        /// RecyclingRewardGas shows how many gas should be recycled as a reward
+        /// </summary>
+        public long RecyclingRewardGas { get; private set; } = 0;
         public UInt160 CurrentScriptHash => CurrentContext?.GetState<ExecutionContextState>().ScriptHash;
         public UInt160 CallingScriptHash => CurrentContext?.GetState<ExecutionContextState>().CallingScriptHash;
         public UInt160 EntryScriptHash => EntryContext?.GetState<ExecutionContextState>().ScriptHash;
@@ -46,9 +52,28 @@ internal T AddDisposable<T>(T disposable) where T : IDisposable
             return disposable;
         }
 
+        internal bool HasUpdatedKey(StorageKey key)
+        {
+            return updatedKeys.Contains(key);
+        }
+
+        internal bool TryAddUpdatedKey(StorageKey key)
+        {
+            bool keyAdded = false;
+            if (!updatedKeys.Contains(key))
+            {
+                updatedKeys.Add(key);
+                keyAdded = true;
+            }
+            return keyAdded;
+        }
+
         private bool AddGas(long gas)
         {
-            GasConsumed = checked(GasConsumed + gas);
+            if (gas < 0)
+                RecyclingRewardGas = checked(RecyclingRewardGas + (-gas));
+            else
+                GasConsumed = checked(GasConsumed + gas);
             return testMode || GasConsumed <= gas_amount;
         }
 
@@ -78,7 +103,7 @@ public override void Dispose()
 
         protected override bool OnSysCall(uint method)
         {
-            if (!AddGas(InteropService.GetPrice(method, CurrentContext.EvaluationStack)))
+            if (!AddGas(InteropService.GetPrice(method, this)))
                 return false;
             return InteropService.Invoke(this, method);
         }

src/neo/SmartContract/InteropDescriptor.cs

@@ -10,6 +10,8 @@ public class InteropDescriptor
         internal Func<ApplicationEngine, bool> Handler { get; }
         public long Price { get; }
         public Func<EvaluationStack, long> PriceCalculator { get; }
+        public Func<ApplicationEngine, long> StoragePriceCalculator { get; }
+        public bool IsStateful { get; } = false;
         public TriggerType AllowedTriggers { get; }
         public CallFlags RequiredCallFlags { get; }
 
@@ -19,6 +21,13 @@ internal InteropDescriptor(string method, Func<ApplicationEngine, bool> handler,
             this.Price = price;
         }
 
+        internal InteropDescriptor(string method, Func<ApplicationEngine, bool> handler, Func<ApplicationEngine, long> priceCalculator, TriggerType allowedTriggers, CallFlags requiredCallFlags)
+            : this(method, handler, allowedTriggers, requiredCallFlags)
+        {
+            this.StoragePriceCalculator = priceCalculator;
+            this.IsStateful = true;
+        }
+
         internal InteropDescriptor(string method, Func<ApplicationEngine, bool> handler, Func<EvaluationStack, long> priceCalculator, TriggerType allowedTriggers, CallFlags requiredCallFlags)
             : this(method, handler, allowedTriggers, requiredCallFlags)
         {
@@ -34,8 +43,33 @@ private InteropDescriptor(string method, Func<ApplicationEngine, bool> handler,
             this.RequiredCallFlags = requiredCallFlags;
         }
 
+        public long GetPrice()
+        {
+            return Price;
+        }
+
+        public long GetPrice(ApplicationEngine applicationEngine)
+        {
+            long price = Price;
+            if (!IsStateful && PriceCalculator != null)
+            {
+                price = PriceCalculator(applicationEngine.CurrentContext.EvaluationStack);
+            }
+            else if (IsStateful && StoragePriceCalculator != null)
+            {
+                price = StoragePriceCalculator(applicationEngine);
+            }
+            return price;
+        }
+
         public long GetPrice(EvaluationStack stack)
         {
+#if DEBUG
+            if (IsStateful)
+            {
+                throw new InvalidOperationException();
+            }
+#endif
             return PriceCalculator is null ? Price : PriceCalculator(stack);
         }
 

src/neo/SmartContract/InteropService.Storage.cs

@@ -12,6 +12,7 @@ partial class InteropService
         public static class Storage
         {
             public const long GasPerByte = 100000;
+            public const long GasPerReleasedByte = -GasPerByte;
             public const int MaxKeySize = 64;
             public const int MaxValueSize = ushort.MaxValue;
 
@@ -22,11 +23,54 @@ public static class Storage
             public static readonly InteropDescriptor Find = Register("System.Storage.Find", Storage_Find, 0_01000000, TriggerType.Application, CallFlags.None);
             public static readonly InteropDescriptor Put = Register("System.Storage.Put", Storage_Put, GetStoragePrice, TriggerType.Application, CallFlags.AllowModifyStates);
             public static readonly InteropDescriptor PutEx = Register("System.Storage.PutEx", Storage_PutEx, GetStoragePrice, TriggerType.Application, CallFlags.AllowModifyStates);
-            public static readonly InteropDescriptor Delete = Register("System.Storage.Delete", Storage_Delete, 0_01000000, TriggerType.Application, CallFlags.AllowModifyStates);
+            public static readonly InteropDescriptor Delete = Register("System.Storage.Delete", Storage_Delete, GetDeletePrice, TriggerType.Application, CallFlags.AllowModifyStates);
 
-            private static long GetStoragePrice(EvaluationStack stack)
+            private static long GetDeletePrice(ApplicationEngine engine)
             {
-                return (stack.Peek(1).GetByteLength() + stack.Peek(2).GetByteLength()) * GasPerByte;
+                var stack = engine.CurrentContext.EvaluationStack;
+                var key = stack.Peek(1);
+                if (!(engine.CurrentContext.EvaluationStack.Peek() is InteropInterface _interface))
+                    return 0_01000000;
+                StorageContext context = _interface.GetInterface<StorageContext>();
+                StorageKey skey = new StorageKey
+                {
+                    Id = context.Id,
+                    Key = key.GetSpan().ToArray()
+                };
+                var skeyValue = engine.Snapshot.Storages.TryGet(skey);
+                if (skeyValue == null || skeyValue.Value == null || skeyValue.Value.Length == 0 || engine.HasUpdatedKey(skey))
+                    return 0_01000000;
+                return (skeyValue.Value.Length + key.GetByteLength()) * GasPerReleasedByte;
+            }
+
+            private static long GetStoragePrice(ApplicationEngine engine)
+            {
+                var stack = engine.CurrentContext.EvaluationStack;
+                var key = stack.Peek(1);
+                var value = stack.Peek(2);
+                var newDataSize = value.IsNull ? 0 : value.GetByteLength();
+                if (!(engine.CurrentContext.EvaluationStack.Peek() is InteropInterface _interface))
+                    return (key.GetByteLength() + newDataSize) * GasPerByte;
+                StorageContext context = _interface.GetInterface<StorageContext>();
+                StorageKey skey = new StorageKey
+                {
+                    Id = context.Id,
+                    Key = key.GetSpan().ToArray()
+                };
+                var skeyValue = engine.Snapshot.Storages.TryGet(skey);
+                if (skeyValue == null || skeyValue.Value == null || skeyValue.Value.Length == 0 || engine.HasUpdatedKey(skey))
+                    return (key.GetByteLength() + newDataSize) * GasPerByte;
+                var currentOccupiedBytes = skeyValue.Value.Length;
+                if (newDataSize <= currentOccupiedBytes)
+                {
+                    var releasedBytes = currentOccupiedBytes - newDataSize;
+                    return releasedBytes * GasPerReleasedByte;
+                }
+                else
+                {
+                    var reusedBytes = currentOccupiedBytes;
+                    return (newDataSize - reusedBytes) * GasPerByte;
+                }
             }
 
             private static bool PutExInternal(ApplicationEngine engine, StorageContext context, byte[] key, byte[] value, StorageFlags flags)
@@ -54,6 +98,7 @@ private static bool PutExInternal(ApplicationEngine engine, StorageContext conte
                     item.Value = value;
                     item.IsConstant = flags.HasFlag(StorageFlags.Constant);
                 }
+                engine.TryAddUpdatedKey(skey);
                 return true;
             }
 
@@ -165,6 +210,7 @@ private static bool Storage_Delete(ApplicationEngine engine)
                     };
                     if (engine.Snapshot.Storages.TryGet(key)?.IsConstant == true) return false;
                     engine.Snapshot.Storages.Delete(key);
+                    engine.TryAddUpdatedKey(key);
                     return true;
                 }
                 return false;

src/neo/SmartContract/InteropService.cs

@@ -15,6 +15,16 @@ static InteropService()
                 t.GetFields()[0].GetValue(null);
         }
 
+        public static long GetPrice(uint hash)
+        {
+            return methods[hash].GetPrice();
+        }
+
+        public static long GetPrice(uint hash, ApplicationEngine applicationEngine)
+        {
+            return methods[hash].GetPrice(applicationEngine);
+        }
+
         public static long GetPrice(uint hash, EvaluationStack stack)
         {
             return methods[hash].GetPrice(stack);
@@ -50,5 +60,12 @@ private static InteropDescriptor Register(string method, Func<ApplicationEngine,
             methods.Add(descriptor.Hash, descriptor);
             return descriptor;
         }
+
+        private static InteropDescriptor Register(string method, Func<ApplicationEngine, bool> handler, Func<ApplicationEngine, long> priceCalculator, TriggerType allowedTriggers, CallFlags flags)
+        {
+            InteropDescriptor descriptor = new InteropDescriptor(method, handler, priceCalculator, allowedTriggers, flags);
+            methods.Add(descriptor.Hash, descriptor);
+            return descriptor;
+        }
     }
 }

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

@@ -54,6 +54,16 @@ protected override bool OnPersist(ApplicationEngine engine)
             return true;
         }
 
+        [ContractMethod(0, ContractParameterType.Boolean, ParameterTypes = new[] { ContractParameterType.Hash160, ContractParameterType.Integer }, ParameterNames = new[] { "account", "amount" })]
+        private StackItem OnRecycleRewardGas(ApplicationEngine engine, VMArray args)
+        {
+            if (engine.Trigger != TriggerType.System) return false;
+            UInt160 acount = new UInt160(args[0].GetSpan());
+            BigInteger amount = args[1].GetBigInteger();
+            Mint(engine, acount, amount);
+            return true;
+        }
+
         [ContractMethod(0_01000000, ContractParameterType.Integer, ParameterTypes = new[] { ContractParameterType.Integer }, ParameterNames = new[] { "index" }, SafeMethod = true)]
         private StackItem GetSysFeeAmount(ApplicationEngine engine, VMArray args)
         {

src/neo/Wallets/Wallet.cs

@@ -354,7 +354,7 @@ public static long CalculateNetworkFee(byte[] witness_script, ref int size)
             if (witness_script.IsSignatureContract())
             {
                 size += 67 + witness_script.GetVarSize();
-                networkFee += ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHNULL] + InteropService.GetPrice(InteropService.Crypto.ECDsaVerify, null);
+                networkFee += ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] + ApplicationEngine.OpCodePrices[OpCode.PUSHNULL] + InteropService.GetPrice(InteropService.Crypto.ECDsaVerify);
             }
             else if (witness_script.IsMultiSigContract(out int m, out int n))
             {
@@ -366,7 +366,7 @@ public static long CalculateNetworkFee(byte[] witness_script, ref int size)
                 networkFee += ApplicationEngine.OpCodePrices[OpCode.PUSHDATA1] * n;
                 using (ScriptBuilder sb = new ScriptBuilder())
                     networkFee += ApplicationEngine.OpCodePrices[(OpCode)sb.EmitPush(n).ToArray()[0]];
-                networkFee += ApplicationEngine.OpCodePrices[OpCode.PUSHNULL] + InteropService.GetPrice(InteropService.Crypto.ECDsaVerify, null) * n;
+                networkFee += ApplicationEngine.OpCodePrices[OpCode.PUSHNULL] + InteropService.GetPrice(InteropService.Crypto.ECDsaVerify) * n;
             }
             else
             {

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

@@ -5,6 +5,7 @@
 using Neo.Network.P2P.Payloads;
 using Neo.SmartContract;
 using Neo.SmartContract.Native;
+using Neo.SmartContract.Native.Tokens;
 using Neo.UnitTests.Extensions;
 using Neo.VM;
 using Neo.VM.Types;
@@ -179,5 +180,53 @@ public void TestGetSysFeeAmount2()
 
             NativeContract.GAS.GetSysFeeAmount(snapshot, 1).Should().Be(sys_fee);
         }
+
+        [TestMethod]
+        public void TestOnRecycleRewardGas()
+        {
+            var wallet = TestUtils.GenerateTestWallet();
+            var snapshot = Blockchain.Singleton.GetSnapshot();
+
+            using (var unlock = wallet.Unlock("123"))
+            {
+                var acc = wallet.CreateAccount();
+
+                // Fake balance
+                var key = NativeContract.GAS.CreateStorageKey(20, acc.ScriptHash);
+
+                var entry = snapshot.Storages.GetAndChange(key, () => new StorageItem
+                {
+                    Value = new Nep5AccountState().ToByteArray()
+                });
+
+                entry.Value = new Nep5AccountState()
+                {
+                    Balance = 10000 * NativeContract.GAS.Factor
+                }
+                .ToByteArray();
+
+                snapshot.Commit();
+
+                NativeContract.GAS.BalanceOf(snapshot, acc.ScriptHash).Should().Be(10000 * NativeContract.GAS.Factor);
+
+                var tx = TestUtils.GetTransaction();
+                tx.Sender = acc.ScriptHash;
+                var recycleRewardGas = (long)(1000 * NativeContract.GAS.Factor);
+
+                Script onRecycleRewardGasScript = null;
+                using (ScriptBuilder sb = new ScriptBuilder())
+                {
+                    sb.EmitAppCall(NativeContract.GAS.Hash, "onRecycleRewardGas", tx.Sender, recycleRewardGas);
+                    sb.Emit(OpCode.THROWIFNOT);
+                    onRecycleRewardGasScript = sb.ToArray();
+                }
+                using (ApplicationEngine engine = new ApplicationEngine(TriggerType.System, null, snapshot, 0, true))
+                {
+                    engine.LoadScript(onRecycleRewardGasScript);
+                    engine.Execute().Should().Be(VMState.HALT);
+                }
+                NativeContract.GAS.BalanceOf(snapshot, acc.ScriptHash).Should().Be(11000 * NativeContract.GAS.Factor);
+            }
+        }
     }
 }