[N4] Whitelist of Free Contracts

docs/native-contracts-api.md

@@ -157,6 +157,8 @@ When calling a native contract method by transaction script, there are several t
 | getAttributeFee | Gets the fee for attribute before Echidna hardfork. NotaryAssisted attribute type not supported. | Byte(*attributeType*) | UInt32 | 1<<15 | 0 | ReadStates | Deprecated in HF_Echidna |
 | getAttributeFee | Gets the fee for attribute after Echidna hardfork. NotaryAssisted attribute type supported. | Byte(*attributeType*) | UInt32 | 1<<15 | 0 | ReadStates | HF_Echidna |
 | isBlocked | Determines whether the specified account is blocked. | UInt160(*account*) | Boolean | 1<<15 | 0 | ReadStates | -- |
+| removeWhitelistFeeContract | Remove whitelisted Fee contracts | UInt160(*contractHash*), String(*method*), Int32(*argCount*) | Void | 1<<15 | 0 | States,AllowNotify | HF_Faun |
+| setWhitelistFeeContract | Set whitelisted Fee contracts | UInt160(*contractHash*), String(*method*), Int32(*argCount*), Int64(*fixedFee*) | Void | 1<<15 | 0 | States,AllowNotify | HF_Faun |
 | setMillisecondsPerBlock | Sets the block generation time in milliseconds. | UInt32(*value*) | Void | 1<<15 | 0 | States,AllowNotify | HF_Echidna |
 | setAttributeFee | Sets the fee for attribute before Echidna hardfork. NotaryAssisted attribute type not supported. | Byte(*attributeType*), UInt32(*value*) | Void | 1<<15 | 0 | States | Deprecated in HF_Echidna |
 | setAttributeFee | Sets the fee for attribute after Echidna hardfork. NotaryAssisted attribute type supported. | Byte(*attributeType*), UInt32(*value*) | Void | 1<<15 | 0 | States | HF_Echidna |
@@ -168,6 +170,7 @@ When calling a native contract method by transaction script, there are several t
 | blockAccount | -- | UInt160(*account*) | Boolean | 1<<15 | 0 | States | -- |
 | unblockAccount | -- | UInt160(*account*) | Boolean | 1<<15 | 0 | States | -- |
 | getBlockedAccounts | -- | -- | StorageIterator | 1<<15 | 0 | ReadStates | HF_Faun |
+| getWhitelistFeeContracts | -- | -- | StorageIterator | 1<<15 | 0 | ReadStates | HF_Faun |
 
 
 ## RoleManagement

src/Neo/SmartContract/ApplicationEngine.cs

@@ -299,6 +299,14 @@ protected static void OnSysCall(ExecutionEngine engine, Instruction instruction)
         /// <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)
         {
+            // Check whitelist
+
+            if (CurrentContext?.GetState<ExecutionContextState>()?.WhiteListed == true)
+            {
+                // The execution is whitelisted
+                return;
+            }
+
 #pragma warning disable CS0618 // Type or member is obsolete
             FeeConsumed = GasConsumed = checked(FeeConsumed + datoshi);
 #pragma warning restore CS0618 // Type or member is obsolete
@@ -341,12 +349,21 @@ private ExecutionContext CallContractInternal(ContractState contract, ContractMe
             else
             {
                 var executingContract = IsHardforkEnabled(Hardfork.HF_Domovoi)
-                ? state.Contract // use executing contract state to avoid possible contract update/destroy side-effects, ref. https://github.com/neo-project/neo/pull/3290.
-                : NativeContract.ContractManagement.GetContract(SnapshotCache, CurrentScriptHash);
+                    ? state.Contract // use executing contract state to avoid possible contract update/destroy side-effects, ref. https://github.com/neo-project/neo/pull/3290.
+                    : NativeContract.ContractManagement.GetContract(SnapshotCache, CurrentScriptHash);
                 if (executingContract?.CanCall(contract, method.Name) == false)
                     throw new InvalidOperationException($"Cannot Call Method {method.Name} Of Contract {contract.Hash} From Contract {CurrentScriptHash}");
             }
 
+            // Check whitelist
+
+            if (IsHardforkEnabled(Hardfork.HF_Faun) &&
+                NativeContract.Policy.IsWhitelistFeeContract(SnapshotCache, contract.Hash, method.Name, method.Parameters.Length, out var fixedFee))
+            {
+                AddFee(fixedFee.Value);
+                state.WhiteListed = true;
+            }
+
             if (invocationCounter.TryGetValue(contract.Hash, out var counter))
             {
                 invocationCounter[contract.Hash] = counter + 1;

src/Neo/SmartContract/ExecutionContextState.cs

@@ -53,5 +53,10 @@ public class ExecutionContextState
         public int NotificationCount { get; set; }
 
         public bool IsDynamicCall { get; set; }
+
+        /// <summary>
+        /// True if the execution is whitelisted by committee
+        /// </summary>
+        public bool WhiteListed { get; set; } = false;
     }
 }

src/Neo/SmartContract/Manifest/ContractAbi.cs

@@ -88,8 +88,10 @@ public ContractMethodDescriptor GetMethod(string name, int pcount)
             if (pcount >= 0)
             {
                 methodDictionary ??= Methods.ToDictionary(p => (p.Name, p.Parameters.Length));
-                methodDictionary.TryGetValue((name, pcount), out var method);
-                return method;
+                if (methodDictionary.TryGetValue((name, pcount), out var method))
+                    return method;
+
+                return null;
             }
             else
             {

src/Neo/SmartContract/Native/ContractManagement.cs

@@ -369,6 +369,11 @@ private ContractTask Update(ApplicationEngine engine, byte[] nefFile, byte[] man
             }
             Helper.Check(new Script(contract.Nef.Script, engine.IsHardforkEnabled(Hardfork.HF_Basilisk)), contract.Manifest.Abi);
             contract.UpdateCounter++; // Increase update counter
+
+            // Clean whitelist (emit event if exists)
+
+            Policy.CleanWhitelist(engine, contract.Hash);
+
             return OnDeployAsync(engine, contract, data, true);
         }
 

src/Neo/SmartContract/Native/NativeContract.cs

@@ -397,6 +397,9 @@ protected static void AssertCommittee(ApplicationEngine engine)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private protected StorageKey CreateStorageKey(byte prefix, UInt256 hash, UInt160 signer) => StorageKey.Create(Id, prefix, hash, signer);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private protected StorageKey CreateStorageKey(byte prefix, UInt160 hash, string methodName, int bigEndianKey) => StorageKey.Create(Id, prefix, hash, methodName, bigEndianKey);
+
         #endregion
 
         /// <summary>
@@ -435,8 +438,17 @@ internal async void Invoke(ApplicationEngine engine, byte version)
                 var state = context.GetState<ExecutionContextState>();
                 if (!state.CallFlags.HasFlag(method.RequiredCallFlags))
                     throw new InvalidOperationException($"Cannot call this method with the flag {state.CallFlags}.");
-                // In the unit of datoshi, 1 datoshi = 1e-8 GAS
-                engine.AddFee(method.CpuFee * engine.ExecFeeFactor + method.StorageFee * engine.StoragePrice);
+                // Check native-whitelist
+                if (engine.IsHardforkEnabled(Hardfork.HF_Faun) && Policy.IsWhitelistFeeContract(engine.SnapshotCache, Hash, method.Name, method.Parameters.Length, out var fixedFee))
+                {
+                    // Whitelisted In the unit of datoshi, 1 datoshi = 1e-8 GAS
+                    engine.AddFee(fixedFee.Value);
+                }
+                else
+                {
+                    // In the unit of datoshi, 1 datoshi = 1e-8 GAS
+                    engine.AddFee(method.CpuFee * engine.ExecFeeFactor + method.StorageFee * engine.StoragePrice);
+                }
                 List<object> parameters = new();
                 if (method.NeedApplicationEngine) parameters.Add(engine);
                 if (method.NeedSnapshot) parameters.Add(engine.SnapshotCache);

src/Neo/SmartContract/Native/PolicyContract.cs

@@ -11,10 +11,13 @@
 
 #pragma warning disable IDE0051
 
+using Neo.Extensions;
 using Neo.Network.P2P.Payloads;
 using Neo.Persistence;
 using Neo.SmartContract.Iterators;
 using System;
+using System.Buffers.Binary;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 
 namespace Neo.SmartContract.Native
@@ -83,6 +86,7 @@ public sealed class PolicyContract : NativeContract
         public const uint MaxMaxTraceableBlocks = 2102400;
 
         private const byte Prefix_BlockedAccount = 15;
+        internal const byte Prefix_WhitelistedFeeContracts = 16;
         private const byte Prefix_FeePerByte = 10;
         private const byte Prefix_ExecFeeFactor = 18;
         private const byte Prefix_StoragePrice = 19;
@@ -103,10 +107,18 @@ public sealed class PolicyContract : NativeContract
         /// </summary>
         private const string MillisecondsPerBlockChangedEventName = "MillisecondsPerBlockChanged";
 
+        private const string WhitelistChangedEventName = "WhitelistChanged";
+
         [ContractEvent(Hardfork.HF_Echidna, 0, name: MillisecondsPerBlockChangedEventName,
             "old", ContractParameterType.Integer,
             "new", ContractParameterType.Integer
         )]
+        [ContractEvent(Hardfork.HF_Faun, 1, name: WhitelistChangedEventName,
+            "contract", ContractParameterType.Hash160,
+            "method", ContractParameterType.String,
+            "argCount", ContractParameterType.Integer,
+            "fee", ContractParameterType.Any
+        )]
         internal PolicyContract() : base()
         {
             _feePerByte = CreateStorageKey(Prefix_FeePerByte);
@@ -258,6 +270,114 @@ public bool IsBlocked(IReadOnlyStore snapshot, UInt160 account)
             return snapshot.Contains(CreateStorageKey(Prefix_BlockedAccount, account));
         }
 
+        internal bool IsWhitelistFeeContract(DataCache snapshot, UInt160 contractHash, string method, int argCount, [NotNullWhen(true)] out long? fixedFee)
+        {
+            // Check contract existence
+
+            var currentContract = ContractManagement.GetContract(snapshot, contractHash);
+
+            if (currentContract != null)
+            {
+                // Check state existence
+
+                var item = snapshot.TryGet(CreateStorageKey(Prefix_WhitelistedFeeContracts, contractHash, method, argCount));
+
+                if (item != null)
+                {
+                    fixedFee = (long)(BigInteger)item;
+                    return true;
+                }
+            }
+
+            fixedFee = null;
+            return false;
+        }
+
+        /// <summary>
+        /// Remove whitelisted Fee contracts
+        /// </summary>
+        /// <param name="engine">The execution engine.</param>
+        /// <param name="contractHash">The contract to set the whitelist</param>
+        /// <param name="method">Method</param>
+        /// <param name="argCount">Argument count</param>
+        [ContractMethod(Hardfork.HF_Faun, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
+        private void RemoveWhitelistFeeContract(ApplicationEngine engine, UInt160 contractHash, string method, int argCount)
+        {
+            if (!CheckCommittee(engine)) throw new InvalidOperationException("Invalid committee signature");
+
+            var key = CreateStorageKey(Prefix_WhitelistedFeeContracts, contractHash, method, argCount);
+
+            if (!engine.SnapshotCache.Contains(key)) throw new InvalidOperationException("Whitelist not found");
+
+            engine.SnapshotCache.Delete(key);
+
+            // Emit event
+            engine.SendNotification(Hash, WhitelistChangedEventName,
+                [new VM.Types.ByteString(contractHash.ToArray()), new VM.Types.ByteString(method.ToStrictUtf8Bytes()),
+                new VM.Types.Integer(argCount), VM.Types.StackItem.Null]);
+        }
+
+        internal int CleanWhitelist(ApplicationEngine engine, UInt160 contractHash)
+        {
+            var count = 0;
+            var searchKey = CreateStorageKey(Prefix_WhitelistedFeeContracts, contractHash);
+
+            foreach ((var key, _) in engine.SnapshotCache.Find(searchKey, SeekDirection.Forward))
+            {
+                engine.SnapshotCache.Delete(key);
+                count++;
+
+                // Emit event recovering the values from the Key
+
+                var keyData = key.ToArray().AsSpan();
+                var argCount = BinaryPrimitives.ReadInt32BigEndian(keyData.Slice(StorageKey.UInt160Length, 4));
+                var method = keyData[(StorageKey.UInt160Length + 4)..];
+
+                engine.SendNotification(Hash, WhitelistChangedEventName,
+                    [new VM.Types.ByteString(contractHash.ToArray()), new VM.Types.ByteString(method.ToArray()),
+                    new VM.Types.Integer(argCount), VM.Types.StackItem.Null]);
+            }
+
+            return count;
+        }
+
+        /// <summary>
+        /// Set whitelisted Fee contracts
+        /// </summary>
+        /// <param name="engine">The execution engine.</param>
+        /// <param name="contractHash">The contract to set the whitelist</param>
+        /// <param name="method">Method</param>
+        /// <param name="argCount">Argument count</param>
+        /// <param name="fixedFee">Fixed execution fee</param>
+        [ContractMethod(Hardfork.HF_Faun, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
+        internal void SetWhitelistFeeContract(ApplicationEngine engine, UInt160 contractHash, string method, int argCount, long fixedFee)
+        {
+            ArgumentOutOfRangeException.ThrowIfNegative(fixedFee, nameof(fixedFee));
+
+            if (!CheckCommittee(engine)) throw new InvalidOperationException("Invalid committee signature");
+
+            var key = CreateStorageKey(Prefix_WhitelistedFeeContracts, contractHash, method, argCount);
+
+            // Validate methods
+            var contract = ContractManagement.GetContract(engine.SnapshotCache, contractHash)
+                    ?? throw new InvalidOperationException("Is not a valid contract");
+
+            if (contract.Manifest.Abi.GetMethod(method, argCount) == null)
+                throw new InvalidOperationException($"{method} with {argCount} args is not a valid method of {contractHash}");
+
+            // Set
+            var entry = engine.SnapshotCache
+                    .GetAndChange(key, () => new StorageItem(fixedFee));
+
+            entry.Set(fixedFee);
+
+            // Emit event
+
+            engine.SendNotification(Hash, WhitelistChangedEventName,
+                [new VM.Types.ByteString(contractHash.ToArray()), new VM.Types.ByteString(method.ToStrictUtf8Bytes()),
+                new VM.Types.Integer(argCount), new VM.Types.Integer(fixedFee)]);
+        }
+
         /// <summary>
         /// Sets the block generation time in milliseconds.
         /// </summary>
@@ -438,5 +558,16 @@ private StorageIterator GetBlockedAccounts(DataCache snapshot)
                 .GetEnumerator();
             return new StorageIterator(enumerator, 1, options);
         }
+
+        [ContractMethod(Hardfork.HF_Faun, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.ReadStates)]
+        internal StorageIterator GetWhitelistFeeContracts(DataCache snapshot)
+        {
+            const FindOptions options = FindOptions.RemovePrefix | FindOptions.KeysOnly;
+            var enumerator = snapshot
+                .Find(CreateStorageKey(Prefix_WhitelistedFeeContracts), SeekDirection.Forward)
+                .GetEnumerator();
+
+            return new StorageIterator(enumerator, 1, options);
+        }
     }
 }

src/Neo/SmartContract/StorageKey.cs

@@ -19,6 +19,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Text;
 
 namespace Neo.SmartContract
 {
@@ -76,7 +77,7 @@ public int Length
         private const int ByteLength = PrefixLength + sizeof(byte);
         private const int Int32Length = PrefixLength + sizeof(int);
         private const int Int64Length = PrefixLength + sizeof(long);
-        private const int UInt160Length = PrefixLength + UInt160.Length;
+        internal const int UInt160Length = PrefixLength + UInt160.Length;
         private const int UInt256Length = PrefixLength + UInt256.Length;
         private const int UInt256UInt160Length = PrefixLength + UInt256.Length + UInt160.Length;
 
@@ -183,6 +184,30 @@ public static StorageKey Create(int id, byte prefix, UInt256 hash, UInt160 signe
             return new(id, data);
         }
 
+        /// <summary>
+        /// Create StorageKey
+        /// </summary>
+        /// <param name="id">The id of the contract.</param>
+        /// <param name="prefix">The prefix of the key.</param>
+        /// <param name="hash">Hash</param>
+        /// <param name="methodName">Method Name</param>
+        /// <param name="bigEndian">Big Endian key.</param>
+        /// <returns>The <see cref="StorageKey"/> class</returns>
+        public static StorageKey Create(int id, byte prefix, UInt160 hash, string methodName, int bigEndian)
+        {
+            const int HashAndInt = UInt160Length + sizeof(int);
+
+            var methodData = Encoding.UTF8.GetBytes(methodName);
+            var data = new byte[HashAndInt + methodData.Length];
+
+            FillHeader(data, id, prefix);
+            hash.Serialize(data.AsSpan(PrefixLength..));
+            BinaryPrimitives.WriteInt32BigEndian(data.AsSpan(UInt160Length..), bigEndian);
+            Array.Copy(methodData, 0, data, HashAndInt, methodData.Length);
+
+            return new(id, data);
+        }
+
         /// <summary>
         /// Create StorageKey
         /// </summary>

tests/Neo.UnitTests/Ledger/UT_StorageKey.cs

@@ -14,6 +14,8 @@
 using Neo.Extensions;
 using Neo.SmartContract;
 using System;
+using System.Buffers.Binary;
+using System.Text;
 
 namespace Neo.UnitTests.Ledger
 {
@@ -76,6 +78,24 @@ public void SameTest()
                 UInt256.Parse("0x761a9bb72ca2a63984db0cc43f943a2a25e464f62d1a91114c2b6fbbfd24b51d"),
                 UInt160.Parse("2d3b96ae1bcc5a585e075e3b81920210dec16302")).ToArray());
 
+            // UInt160+String+Int
+            key = new KeyBuilder(1, 2);
+            key.Add(UInt160.Parse("2d3b96ae1bcc5a585e075e3b81920210dec16302"));
+            key.AddBigEndian((int)3); // arg count
+            key.Add(Encoding.UTF8.GetBytes("hello world"));
+
+            CollectionAssert.AreEqual(key.ToArray(), StorageKey.Create(1, 2,
+                UInt160.Parse("2d3b96ae1bcc5a585e075e3b81920210dec16302"), "hello world", 3).ToArray());
+
+            // Recover method and arg count
+
+            var keyB = new StorageKey(key.ToArray()).ToArray().AsSpan();
+            var argCount = BinaryPrimitives.ReadInt32BigEndian(keyB.Slice(StorageKey.UInt160Length, 4));
+            var method = keyB[(StorageKey.UInt160Length + 4)..];
+
+            Assert.AreEqual(3, argCount);
+            Assert.AreEqual("hello world", Encoding.UTF8.GetString(method));
+
             // ISerializable
             key = new KeyBuilder(1, 2);
             key.Add(ECCurve.Secp256r1.G);