public static bool CheckCertificateOperationRequestSignature(byte[] operation, byte[] signature,
                                                                     Certificate certificate, Certificate signerCertificate)
        {
            byte[] dataForSign = ArrayUtil.Concat(operation, certificate.EncodedValue);
            if (ArrayUtil.Contains(signerCertificate.PublicKeyAlgName, Constants.ALG_NAME_RSA_UPPERCASE) ||
                ArrayUtil.Contains(signerCertificate.PublicKeyAlgName, Constants.ALG_NAME_RSA_LOWERCASE))
            {
#if NET_CORE
                return(NetCoreSignatureValidator.CheckRSAPSSSha256Signature(signature, dataForSign,
                                                                            signerCertificate.SubjectPublicKeyInfo));
#endif
#if NEO
                return(NeoVMSignatureValidator.CheckSignature(NATIVE_CONTRACT_SHA256WithRSAPSS_ALG_CODE, signature,
                                                              dataForSign,
                                                              signerCertificate.SubjectPublicKeyInfo));
#endif
            }
            else if (ArrayUtil.Contains(signerCertificate.PublicKeyAlgName, Constants.ALG_NAME_EC_UPPERCASE) ||
                     ArrayUtil.Contains(signerCertificate.PublicKeyAlgName, Constants.ALG_NAME_EC_LOWERCASE))
            {
#if NET_CORE
                return(NetCoreSignatureValidator.CheckECDSASha256Signature(signature, dataForSign,
                                                                           signerCertificate.SubjectPublicKeyInfo));
#endif
#if NEO
                return(NeoVMSignatureValidator.CheckSignature(NATIVE_CONTRACT_ECDSAWithSHA256_ALG_CODE, signature,
                                                              dataForSign,
                                                              signerCertificate.SubjectPublicKeyInfo));
#endif
            }

            Logger.log("Unknown Certificate Public Key Algorithm");
            Logger.log(signerCertificate.PublicKeyAlgName);
            return(false);
        }
        public static object VerifyCertificateSignature(object[] args)
        {
            byte[] encodedCert       = (byte[])args[0];
            byte[] encodedIssuerCert = (byte[])args[1];
            Logger.log("VerifyCertificateSignature started");
            bool result = NeoVMSignatureValidator.CheckCertificateSignature(encodedCert, encodedIssuerCert);

            Logger.log("VerifyCertificateSignature finished");
            Logger.log(result);
            return(result);
        }
        public static bool ValidateCertificateSignature(Certificate certificate, Certificate issuerCertificate)
        {
#if NEO
            return(NeoVMSignatureValidator.CheckCertificateSignature(certificate.EncodedValue, issuerCertificate.EncodedValue));
#endif
#if NET_CORE
            SignedData signedData = new SignedData();
            signedData.subjectPublicKeyInfo = issuerCertificate.SubjectPublicKeyInfo;
            signedData.signedData           = certificate.TbsCertificate;
            signedData.signatureAlgorithm   = certificate.SignatureAlgorithm;
            signedData.signatureValue       = certificate.Signature;
            return(NetCoreSignatureValidator.Validate(signedData));
#endif
        }
        public static bool CheckUntrustRootCARequestSignature(byte[] signature, byte[] signed)
        {
#if NEO
            byte[] dataForSign = ArrayUtil.Concat(OPERATION_UNTRUST_ROOT_CA_CERTIFICATE, signed);
            return(NeoVMSignatureValidator.CheckSignature(NATIVE_CONTRACT_ECDSAWithSHA256_ALG_CODE, signature,
                                                          dataForSign,
                                                          ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
#if NET_CORE
            byte[] dataForSign = ArrayUtil.Concat(OPERATION_UNTRUST_ROOT_CA_CERTIFICATE, signed);
            return(NetCoreSignatureValidator.CheckECDSASha256Signature(signature, dataForSign,
                                                                       ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
        }
        public static bool CheckRejectFraudRequestSignature(byte[] fraudId, byte[] signature)
        {
            byte[] operation   = OPERATION_REJECT_FRAUD_REPORT;
            byte[] dataForSign = ArrayUtil.Concat(operation, fraudId);

#if NEO
            return(NeoVMSignatureValidator.CheckSignature(NATIVE_CONTRACT_ECDSAWithSHA256_ALG_CODE, signature,
                                                          dataForSign,
                                                          ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
#if NET_CORE
            return(NetCoreSignatureValidator.CheckECDSASha256Signature(signature, dataForSign,
                                                                       ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
        }
        public static bool CheckApproveFraudRequestSignature(byte[] fraudId, byte[] signature)
        {
            byte[] operation   = OPERATION_APPROVE_FRAUD_REPORT;
            byte[] dataForSign = ArrayUtil.Concat(operation, fraudId);
            Logger.log("[Smart Contract]-Data For Sign (For Approve Fraud)");
            Logger.log((dataForSign));

#if NEO
            Logger.log("[Smart Contract]Signature Value (For Approve Fraud)");
            Logger.log((signature));
            return(NeoVMSignatureValidator.CheckSignature(NATIVE_CONTRACT_ECDSAWithSHA256_ALG_CODE, signature,
                                                          dataForSign,
                                                          ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
#if NET_CORE
            return(NetCoreSignatureValidator.CheckECDSASha256Signature(signature, dataForSign,
                                                                       ROOT_CA_REQUEST_SIGNATURE_VALIDATION_PUBLIC_KEY_SUBJECT_PUBLIC_KEY_INFO));
#endif
        }