[N3] Request blocked funds

src/Neo/SmartContract/Native/NativeContract.cs

@@ -364,6 +364,24 @@ protected static void AssertCommittee(ApplicationEngine engine)
                 throw new InvalidOperationException("Invalid committee signature. It should be a multisig(len(committee) - (len(committee) - 1) / 2)).");
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected static UInt160 AssertAlmostFullCommittee(ApplicationEngine engine)
+        {
+            // Signed by 19/21 committee members
+
+            UInt160 committeeMultiSigAddr;
+            var committees = NativeContract.NEO.GetCommittee(engine.SnapshotCache);
+
+            // Min must be almost the committee address
+            var min = Math.Max(1, committees.Length - (committees.Length - 1) / 2);
+            committeeMultiSigAddr = Contract.CreateMultiSigRedeemScript(Math.Max(min, committees.Length - 2), committees).ToScriptHash();
+
+            if (!engine.CheckWitnessInternal(committeeMultiSigAddr))
+                throw new InvalidOperationException("Invalid committee signature. It should be a multisig(max(1,len(committee) - 2))).");
+
+            return committeeMultiSigAddr;
+        }
+
         #region Storage keys
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Neo/SmartContract/Native/PolicyContract.cs

@@ -16,8 +16,10 @@
 using Neo.Persistence;
 using Neo.SmartContract.Iterators;
 using Neo.SmartContract.Manifest;
+using Neo.VM.Types;
 using System;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Numerics;
@@ -103,12 +105,13 @@ public sealed class PolicyContract : NativeContract
         private readonly StorageKey _millisecondsPerBlock;
         private readonly StorageKey _maxValidUntilBlockIncrement;
         private readonly StorageKey _maxTraceableBlocks;
+        private const ulong RequiredTimeForRecoverFunds = 365 * 24 * 60 * 60 * 1_000UL; // 1 year in milliseconds
 
         /// <summary>
         /// The event name for the block generation time changed.
         /// </summary>
         private const string MillisecondsPerBlockChangedEventName = "MillisecondsPerBlockChanged";
-
+        private const string RecoveredFundsEventName = "RecoveredFunds";
         private const string WhitelistChangedEventName = "WhitelistFeeChanged";
 
         [ContractEvent(Hardfork.HF_Echidna, 0, name: MillisecondsPerBlockChangedEventName,
@@ -121,6 +124,7 @@ public sealed class PolicyContract : NativeContract
             "argCount", ContractParameterType.Integer,
             "fee", ContractParameterType.Any
         )]
+        [ContractEvent(Hardfork.HF_Faun, 2, name: RecoveredFundsEventName, "account", ContractParameterType.Hash160)]
         internal PolicyContract() : base()
         {
             _feePerByte = CreateStorageKey(Prefix_FeePerByte);
@@ -583,12 +587,27 @@ internal async ContractTask<bool> BlockAccountInternal(ApplicationEngine engine,
 
             var key = CreateStorageKey(Prefix_BlockedAccount, account);
 
-            if (engine.SnapshotCache.Contains(key)) return false;
+            var blockData = engine.SnapshotCache.TryGet(key);
+            if (blockData != null)
+            {
+                // Check if it is stored the recover funds time
+                if (blockData.Value.Length == 0 && engine.IsHardforkEnabled(Hardfork.HF_Faun))
+                {
+                    // Don't modify it if already exists
+                    blockData.Set(engine.GetTime());
+                }
+
+                return false;
+            }
 
             if (engine.IsHardforkEnabled(Hardfork.HF_Faun))
                 await NEO.VoteInternal(engine, account, null);
 
-            engine.SnapshotCache.Add(key, new StorageItem([]));
+            engine.SnapshotCache.Add(key,
+                // Set request time for recover funds
+                engine.IsHardforkEnabled(Hardfork.HF_Faun) ? new StorageItem(engine.GetTime())
+                : new StorageItem([]));
+
             return true;
         }
 
@@ -597,7 +616,6 @@ private bool UnblockAccount(ApplicationEngine engine, UInt160 account)
         {
             AssertCommittee(engine);
 
-
             var key = CreateStorageKey(Prefix_BlockedAccount, account);
             if (!engine.SnapshotCache.Contains(key)) return false;
 
@@ -615,6 +633,76 @@ private StorageIterator GetBlockedAccounts(DataCache snapshot)
             return new StorageIterator(enumerator, 1, options);
         }
 
+        [ContractMethod(Hardfork.HF_Faun, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.States | CallFlags.AllowNotify)]
+        internal async ContractTask RecoverFunds(ApplicationEngine engine, UInt160 account, VM.Types.Array extraTokens)
+        {
+            var committeeMultiSigAddr = AssertAlmostFullCommittee(engine);
+
+            // Set request time
+
+            var key = CreateStorageKey(Prefix_BlockedAccount, account);
+            var entry = engine.SnapshotCache.GetAndChange(key, null)
+                ?? throw new InvalidOperationException("Request not found.");
+            if (engine.GetTime() - (BigInteger)entry < RequiredTimeForRecoverFunds)
+                throw new InvalidOperationException("Request must be signed at least 1 year ago.");
+
+            // Validate and collect extra NEP17 tokens
+
+            var validatedTokens = new HashSet<UInt160>
+            {
+                NEO.Hash,
+                GAS.Hash
+            };
+
+            foreach (var tokenItem in extraTokens)
+            {
+                var span = tokenItem.GetSpan();
+                if (span.Length != UInt160.Length)
+                    throw new ArgumentException($"Invalid token hash length: expected {UInt160.Length} bytes, got {span.Length} bytes.");
+
+                var contractHash = new UInt160(span);
+
+                // Validate contract exists
+                var contract = ContractManagement.GetContract(engine.SnapshotCache, contractHash);
+                if (contract == null)
+                    throw new InvalidOperationException($"Contract {contractHash} does not exist.");
+
+                // Validate contract implements NEP-17 standard
+                if (!contract.Manifest.SupportedStandards.Contains("NEP-17"))
+                    throw new InvalidOperationException($"Contract {contractHash} does not implement NEP-17 standard.");
+
+                // Prevent NEO and GAS from being in extraTokens
+                if (contractHash == NEO.Hash || contractHash == GAS.Hash)
+                    throw new InvalidOperationException($"NEO and GAS should not be included in extraTokens. They are automatically processed.");
+
+                // Prevent duplicate tokens
+                if (!validatedTokens.Add(contractHash))
+                    throw new InvalidOperationException($"Duplicate token {contractHash} in extraTokens.");
+            }
+
+            // Remove and notify
+
+            engine.SendNotification(Hash, RecoveredFundsEventName, [new ByteString(account.ToArray())]);
+
+            // Transfer funds, NEO, GAS and extra NEP17 tokens
+
+            foreach (var contractHash in validatedTokens)
+            {
+                // Check balance
+                var balance = await engine.CallFromNativeContractAsync<BigInteger>(account, contractHash, "balanceOf", account.ToArray());
+
+                if (balance > 0)
+                {
+                    // transfer
+                    var result = await engine.CallFromNativeContractAsync<bool>(account, contractHash, "transfer",
+                        account.ToArray(), NativeContract.Treasury.Hash.ToArray(), balance, StackItem.Null);
+
+                    if (!result)
+                        throw new InvalidOperationException($"Transfer of {balance} from {account} to {committeeMultiSigAddr} failed in contract {contractHash}.");
+                }
+            }
+        }
+
         [ContractMethod(Hardfork.HF_Faun, CpuFee = 1 << 15, RequiredCallFlags = CallFlags.ReadStates)]
         internal StorageIterator GetWhitelistFeeContracts(DataCache snapshot)
         {

tests/Neo.UnitTests/Extensions/NativeContractExtensions.cs

@@ -80,10 +80,26 @@ public static void UpdateContract(this DataCache snapshot, UInt160 callingScript
 
         public static void DestroyContract(this DataCache snapshot, UInt160 callingScriptHash)
         {
+            var persistingBlock = new Block()
+            {
+                Header = new Header()
+                {
+                    Index = 0,
+                    MerkleRoot = UInt256.Zero,
+                    Timestamp = 0,
+                    Witness = Witness.Empty,
+                    NextConsensus = UInt160.Zero,
+                    Nonce = 0,
+                    PrevHash = UInt256.Zero,
+                },
+                Transactions = []
+            };
+
             var script = new ScriptBuilder();
             script.EmitDynamicCall(NativeContract.ContractManagement.Hash, "destroy");
 
-            var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, settings: TestProtocolSettings.Default);
+            var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot,
+                persistingBlock: persistingBlock, settings: TestProtocolSettings.Default);
             engine.LoadScript(script.ToArray());
 
             // Fake calling script hash