Exec Factor with decimals

src/Neo/SmartContract/ApplicationEngine.Runtime.cs

@@ -447,7 +447,7 @@ protected internal void BurnGas(long datoshi)
         {
             if (datoshi <= 0)
                 throw new InvalidOperationException("GAS must be positive.");
-            AddFee(datoshi);
+            AddFee(datoshi * FeeFactor);
         }
 
         /// <summary>

src/Neo/SmartContract/ApplicationEngine.cs

@@ -65,8 +65,11 @@ public partial class ApplicationEngine : ExecutionEngine
 
         private static Dictionary<uint, InteropDescriptor> services;
         // Total amount of GAS spent to execute.
-        // In the unit of datoshi, 1 datoshi = 1e-8 GAS, 1 GAS = 1e8 datoshi
-        private readonly long _feeAmount;
+        // In the unit of pico-datoshi, 1 datoshi = 1e-8 GAS, 1 GAS = 1e8 datoshi
+        private readonly BigInteger _feeAmount;
+        private BigInteger _feeConsumed;
+        // Decimals for fee calculation
+        public const uint FeeFactor = 10000;
         private Dictionary<Type, object> states;
         private readonly DataCache originalSnapshotCache;
         private List<NotifyEventArgs> notifications;
@@ -131,19 +134,19 @@ public partial class ApplicationEngine : ExecutionEngine
         /// In the unit of datoshi, 1 datoshi = 1e-8 GAS, 1 GAS = 1e8 datoshi
         /// </summary>
         [Obsolete("This property is deprecated. Use FeeConsumed instead.")]
-        public long GasConsumed { get; protected set; } = 0;
+        public long GasConsumed => FeeConsumed;
 
         /// <summary>
         /// GAS spent to execute.
         /// In the unit of datoshi, 1 datoshi = 1e-8 GAS, 1 GAS = 1e8 datoshi
         /// </summary>
-        public long FeeConsumed { get; protected set; } = 0;
+        public long FeeConsumed => (long)_feeConsumed.CeilingDivide(FeeFactor);
 
         /// <summary>
         /// The remaining GAS that can be spent in order to complete the execution.
         /// In the unit of datoshi, 1 datoshi = 1e-8 GAS, 1 GAS = 1e8 datoshi
         /// </summary>
-        public long GasLeft => _feeAmount - FeeConsumed;
+        public long GasLeft => (long)(_feeAmount.CeilingDivide(FeeFactor) - FeeConsumed);
 
         /// <summary>
         /// The exception that caused the execution to terminate abnormally. This field could be <see langword="null"/> if no exception is thrown.
@@ -205,18 +208,28 @@ protected ApplicationEngine(
             originalSnapshotCache = snapshotCache;
             PersistingBlock = persistingBlock;
             ProtocolSettings = settings;
-            _feeAmount = gas;
+            _feeAmount = gas * FeeFactor;
             Diagnostic = diagnostic;
             nonceData = container is Transaction tx ? tx.Hash.ToArray()[..16] : new byte[16];
             if (snapshotCache is null || persistingBlock?.Index == 0)
             {
-                ExecFeeFactor = PolicyContract.DefaultExecFeeFactor;
-                StoragePrice = PolicyContract.DefaultStoragePrice;
+                ExecFeeFactor = PolicyContract.DefaultExecFeeFactor * FeeFactor; // Add fee decimals
+                StoragePrice = PolicyContract.DefaultStoragePrice * FeeFactor;
             }
             else
             {
-                ExecFeeFactor = NativeContract.Policy.GetExecFeeFactor(snapshotCache);
-                StoragePrice = NativeContract.Policy.GetStoragePrice(snapshotCache);
+                if (!settings.IsHardforkEnabled(Hardfork.HF_Faun, persistingBlock?.Index ?? 0))
+                {
+                    // The values doesn't have the decimals stored
+                    ExecFeeFactor = NativeContract.Policy.GetExecFeeFactor(snapshotCache) * FeeFactor;
+                    StoragePrice = NativeContract.Policy.GetStoragePrice(snapshotCache) * FeeFactor;
+                }
+                else
+                {
+                    // The values have the decimals stored
+                    ExecFeeFactor = NativeContract.Policy.GetExecFeeFactor(snapshotCache);
+                    StoragePrice = NativeContract.Policy.GetStoragePrice(snapshotCache);
+                }
             }
 
             if (persistingBlock is not null)
@@ -296,13 +309,11 @@ protected static void OnSysCall(ExecutionEngine engine, Instruction instruction)
         /// <summary>
         /// Adds GAS to <see cref="FeeConsumed"/> and checks if it has exceeded the maximum limit.
         /// </summary>
-        /// <param name="datoshi">The amount of GAS, in the unit of datoshi, 1 datoshi = 1e-8 GAS, to be added.</param>
-        protected internal void AddFee(long datoshi)
+        /// <param name="picoDatoshi">The amount of GAS, in the unit of pico-datoshi, 1 datoshi = 1e-8 GAS, to be added.</param>
+        protected internal void AddFee(long picoDatoshi)
         {
-#pragma warning disable CS0618 // Type or member is obsolete
-            FeeConsumed = GasConsumed = checked(FeeConsumed + datoshi);
-#pragma warning restore CS0618 // Type or member is obsolete
-            if (FeeConsumed > _feeAmount)
+            _feeConsumed = checked(_feeConsumed + picoDatoshi);
+            if (_feeConsumed > _feeAmount)
                 throw new InvalidOperationException("Insufficient GAS.");
         }
 

src/Neo/SmartContract/Native/NeoToken.cs

@@ -371,7 +371,7 @@ private bool RegisterCandidate(ApplicationEngine engine, ECPoint pubkey)
                 !engine.CheckWitnessInternal(Contract.CreateSignatureRedeemScript(pubkey).ToScriptHash()))
                 return false;
             // In the unit of datoshi, 1 datoshi = 1e-8 GAS
-            engine.AddFee(GetRegisterPrice(engine.SnapshotCache));
+            engine.AddFee(GetRegisterPrice(engine.SnapshotCache) * ApplicationEngine.FeeFactor);
             return RegisterInternal(engine, pubkey);
         }
 

src/Neo/SmartContract/Native/OracleContract.cs

@@ -218,10 +218,10 @@ private async ContractTask Request(ApplicationEngine engine, string url, string
             if (gasForResponse < 0_10000000)
                 throw new ArgumentException($"gasForResponse {gasForResponse} must be at least 0.1 datoshi.");
 
-            engine.AddFee(GetPrice(engine.SnapshotCache));
+            engine.AddFee(GetPrice(engine.SnapshotCache) * ApplicationEngine.FeeFactor);
 
             //Mint gas for the response
-            engine.AddFee(gasForResponse);
+            engine.AddFee(gasForResponse * ApplicationEngine.FeeFactor);
             await GAS.Mint(engine, Hash, gasForResponse, false);
 
             //Increase the request id

src/Neo/SmartContract/Native/PolicyContract.cs

@@ -132,6 +132,18 @@ internal override ContractTask InitializeAsync(ApplicationEngine engine, Hardfor
                 engine.SnapshotCache.Add(_maxValidUntilBlockIncrement, new StorageItem(engine.ProtocolSettings.MaxValidUntilBlockIncrement));
                 engine.SnapshotCache.Add(_maxTraceableBlocks, new StorageItem(engine.ProtocolSettings.MaxTraceableBlocks));
             }
+            if (hardfork == Hardfork.HF_Faun)
+            {
+                // Add decimals to exec fee factor
+                var item = engine.SnapshotCache.TryGet(_execFeeFactor) ??
+                    throw new InvalidOperationException("Policy was not initialized");
+                item.Set((uint)(BigInteger)item * ApplicationEngine.FeeFactor);
+
+                // Add decimals to storage price
+                item = engine.SnapshotCache.TryGet(_storagePrice) ??
+                    throw new InvalidOperationException("Policy was not initialized");
+                item.Set((uint)(BigInteger)item * ApplicationEngine.FeeFactor);
+            }
             return ContractTask.CompletedTask;
         }
 
@@ -342,17 +354,23 @@ private void SetFeePerByte(ApplicationEngine engine, long value)
         [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States)]
         private void SetExecFeeFactor(ApplicationEngine engine, uint value)
         {
-            if (value == 0 || value > MaxExecFeeFactor)
-                throw new ArgumentOutOfRangeException(nameof(value), $"ExecFeeFactor must be between [1, {MaxExecFeeFactor}], got {value}");
+            // After FAUN hardfork, the max exec fee factor is with decimals defined in ApplicationEngine.FeeFactor
+            var maxValue = engine.IsHardforkEnabled(Hardfork.HF_Faun) ? ApplicationEngine.FeeFactor * MaxExecFeeFactor : MaxExecFeeFactor;
+
+            if (value == 0 || value > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(value), $"ExecFeeFactor must be between [1, {maxValue}], got {value}");
             if (!CheckCommittee(engine)) throw new InvalidOperationException();
             engine.SnapshotCache.GetAndChange(_execFeeFactor).Set(value);
         }
 
         [ContractMethod(CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States)]
         private void SetStoragePrice(ApplicationEngine engine, uint value)
         {
-            if (value == 0 || value > MaxStoragePrice)
-                throw new ArgumentOutOfRangeException(nameof(value), $"StoragePrice must be between [1, {MaxStoragePrice}], got {value}");
+            // After FAUN hardfork, the max exec fee factor is with decimals defined in ApplicationEngine.FeeFactor
+            var maxValue = engine.IsHardforkEnabled(Hardfork.HF_Faun) ? (ulong)ApplicationEngine.FeeFactor * MaxStoragePrice : MaxStoragePrice;
+
+            if (value == 0 || value > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(value), $"StoragePrice must be between [1, {maxValue}], got {value}");
             if (!CheckCommittee(engine)) throw new InvalidOperationException();
             engine.SnapshotCache.GetAndChange(_storagePrice).Set(value);
         }

tests/Neo.Extensions.Tests/UT_BigIntegerExtensions.cs

@@ -29,6 +29,7 @@ public void CeilingDivide_NegativeNumerator()
             var result = BigIntegerExtensions.CeilingDivide(numerator, denominator);
             Assert.AreEqual(-2, result);
         }
+
         [TestMethod]
         public void CeilingDivide_DividesExactly()
         {