[Neo Rpc Methods] fix contract rpc methods parameters

src/Plugins/RpcServer/Model/SignerWithWitness.cs

@@ -0,0 +1,106 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// SignerWithWitness.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+#nullable enable
+
+using Neo.Cryptography.ECC;
+using Neo.Json;
+using Neo.Network.P2P.Payloads;
+using Neo.Wallets;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Neo.Plugins.RpcServer.Model;
+
+public class SignerWithWitness(Signer? signer, Witness? witness)
+{
+    public Signer? Signer { get; } = signer;
+    public Witness? Witness { get; } = witness;
+
+    public static bool TryParse(JToken value, ProtocolSettings settings, [NotNullWhen(true)] out SignerWithWitness? signerWithWitness)
+    {
+        signerWithWitness = null;
+
+        if (value == null)
+            return false;
+
+        if (value is JObject jObject)
+        {
+            Signer? signer = null;
+            Witness? witness = null;
+
+            if (jObject.ContainsProperty("account"))
+            {
+                signer = SignerFromJson(jObject, settings);
+            }
+            if (jObject.ContainsProperty("invocation") || jObject.ContainsProperty("verification"))
+            {
+                witness = WitnessFromJson(jObject);
+            }
+
+            if (signer != null || witness != null)
+            {
+                signerWithWitness = new SignerWithWitness(signer, witness);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static Signer SignerFromJson(JObject jObject, ProtocolSettings settings)
+    {
+        return new Signer
+        {
+            Account = AddressToScriptHash(jObject["account"].AsString(), settings.AddressVersion),
+            Scopes = (WitnessScope)Enum.Parse(typeof(WitnessScope), jObject["scopes"]?.AsString()),
+            AllowedContracts = ((JArray)jObject["allowedcontracts"])?.Select(p => UInt160.Parse(p.AsString())).ToArray() ?? Array.Empty<UInt160>(),
+            AllowedGroups = ((JArray)jObject["allowedgroups"])?.Select(p => ECPoint.Parse(p.AsString(), ECCurve.Secp256r1)).ToArray() ?? Array.Empty<ECPoint>(),
+            Rules = ((JArray)jObject["rules"])?.Select(r => WitnessRule.FromJson((JObject)r)).ToArray() ?? Array.Empty<WitnessRule>(),
+        };
+    }
+
+    private static Witness WitnessFromJson(JObject jObject)
+    {
+        return new Witness
+        {
+            InvocationScript = Convert.FromBase64String(jObject["invocation"]?.AsString() ?? string.Empty),
+            VerificationScript = Convert.FromBase64String(jObject["verification"]?.AsString() ?? string.Empty)
+        };
+    }
+
+    public static SignerWithWitness[] ParseArray(JArray array, ProtocolSettings settings)
+    {
+        if (array == null)
+            throw new ArgumentNullException(nameof(array));
+
+        if (array.Count > Transaction.MaxTransactionAttributes)
+            throw new RpcException(RpcError.InvalidParams.WithData("Max allowed signers or witnesses exceeded."));
+
+        return array.Select(item =>
+        {
+            if (TryParse(item, settings, out var signerWithWitness))
+                return signerWithWitness;
+            throw new ArgumentException($"Invalid signer or witness format: {item}");
+        }).ToArray();
+    }
+
+    private static UInt160 AddressToScriptHash(string address, byte version)
+    {
+        if (UInt160.TryParse(address, out var scriptHash))
+        {
+            return scriptHash;
+        }
+
+        return address.ToScriptHash(version);
+    }
+}

src/Plugins/RpcServer/ParameterConverter.cs

@@ -10,10 +10,13 @@
 // modifications are permitted.
 
 using Neo.Json;
+using Neo.Network.P2P.Payloads;
 using Neo.Plugins.RpcServer.Model;
+using Neo.SmartContract;
 using Neo.Wallets;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using JToken = Neo.Json.JToken;
 
 namespace Neo.Plugins.RpcServer;
@@ -39,7 +42,12 @@ static ParameterConverter()
             { typeof(bool), token => Result.Ok_Or(token.AsBoolean, CreateInvalidParamError<bool>(token)) },
             { typeof(UInt256), ConvertUInt256 },
             { typeof(ContractNameOrHashOrId), ConvertContractNameOrHashOrId },
-            { typeof(BlockHashOrIndex), ConvertBlockHashOrIndex }
+            { typeof(BlockHashOrIndex), ConvertBlockHashOrIndex },
+            { typeof(Signer), ConvertSigner },
+            { typeof(ContractParameter), ConvertContractParameter },
+            { typeof(Signer[]), ConvertSignerArray },
+            { typeof(ContractParameter[]), ConvertContractParameterArray },
+            { typeof(Guid), ConvertGuid }
         };
     }
 
@@ -107,6 +115,23 @@ internal static object ConvertUInt160(JToken token, byte addressVersion)
             RpcError.InvalidParams.WithData($"Invalid UInt160 Format: {token}"));
     }
 
+    internal static object ConvertSignerWithWitnessArray(JToken token, ProtocolSettings settings)
+    {
+        if (token is JArray jArray)
+        {
+            return SignerWithWitness.ParseArray(jArray, settings);
+        }
+
+        if (token is JObject jObject)
+        {
+            if (SignerWithWitness.TryParse(jObject, settings, out var signerWithWitness))
+            {
+                return new[] { signerWithWitness };
+            }
+        }
+        throw new RpcException(RpcError.InvalidParams.WithData($"Invalid SignerWithWitness format: {token}"));
+    }
+
     private static object ConvertUInt256(JToken token)
     {
         if (UInt256.TryParse(token.AsString(), out var hash))
@@ -134,6 +159,79 @@ private static object ConvertBlockHashOrIndex(JToken token)
         throw new RpcException(RpcError.InvalidParams.WithData($"Invalid block hash or index Format: {token}"));
     }
 
+    private static object ConvertSigner(JToken token)
+    {
+        if (token is JObject jObject)
+        {
+            try
+            {
+                return Signer.FromJson(jObject);
+            }
+            catch (FormatException)
+            {
+                throw new RpcException(CreateInvalidParamError<Signer>(token));
+            }
+        }
+        throw new RpcException(CreateInvalidParamError<Signer>(token));
+    }
+
+    private static object ConvertContractParameter(JToken token)
+    {
+        if (token is JObject jObject)
+        {
+            try
+            {
+                return ContractParameter.FromJson(jObject);
+            }
+            catch (FormatException)
+            {
+                throw new RpcException(CreateInvalidParamError<ContractParameter>(token));
+            }
+        }
+        throw new RpcException(CreateInvalidParamError<ContractParameter>(token));
+    }
+
+    private static object ConvertSignerArray(JToken token)
+    {
+        if (token is JArray jArray)
+        {
+            try
+            {
+                return jArray.Select(t => Signer.FromJson(t as JObject)).ToArray();
+            }
+            catch (FormatException)
+            {
+                throw new RpcException(CreateInvalidParamError<Signer[]>(token));
+            }
+        }
+        throw new RpcException(CreateInvalidParamError<Signer[]>(token));
+    }
+
+    private static object ConvertContractParameterArray(JToken token)
+    {
+        if (token is JArray jArray)
+        {
+            try
+            {
+                return jArray.Select(t => ContractParameter.FromJson(t as JObject)).ToArray();
+            }
+            catch (FormatException)
+            {
+                throw new RpcException(CreateInvalidParamError<ContractParameter[]>(token));
+            }
+        }
+        throw new RpcException(CreateInvalidParamError<ContractParameter[]>(token));
+    }
+
+    private static object ConvertGuid(JToken token)
+    {
+        if (Guid.TryParse(token.AsString(), out var guid))
+        {
+            return guid;
+        }
+        throw new RpcException(CreateInvalidParamError<Guid>(token));
+    }
+
     private static RpcError CreateInvalidParamError<T>(JToken token)
     {
         return RpcError.InvalidParams.WithData($"Invalid {typeof(T)} value: {token}");