Updates for kernel bindings tests version 0.0.2 (#8)

janb84 · web-flow · commit f0f14b4ed07b · 2025-12-03T09:44:17.000+01:00
* Refactor script verification handling / json parsing to use new specifications of Kernel-bindings-handler
* Refactor Response class to replace 'Success' property with 'Result' 
* Refactor Response class add new structure of the Error response.
* Update CI configuration kernel_bindings_tests to version 0.0.2
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -96,7 +96,7 @@ jobs:
             platform: linux_amd64
 
     env:
-      TEST_VERSION: '0.0.1'
+      TEST_VERSION: '0.0.2'
       TEST_REPO: 'stringintech/kernel-bindings-tests'
       TEST_DIR: '.conformance-tests'
 
diff --git a/tools/kernel-bindings-test-handler/Handlers/ScriptVerifyHandler.cs b/tools/kernel-bindings-test-handler/Handlers/ScriptVerifyHandler.cs
@@ -22,7 +22,7 @@ public ScriptVerifyHandler(KernelContext context)
     /// <summary>
     /// Handles a script verification request.
     /// </summary>
-    public Response Handle(string requestId, ScriptVerifyParams parameters)
+    public Response Handle(string requestId, BtckScriptPubkeyVerifyParams parameters)
     {
         try
         {
@@ -37,7 +37,7 @@ public Response Handle(string requestId, ScriptVerifyParams parameters)
                 foreach (var output in parameters.SpentOutputs)
                 {
                     var outputScriptPubKey = ScriptPubKey.FromHex(output.ScriptPubKeyHex);
-                    spentOutputs.Add(new TxOut(outputScriptPubKey, output.Amount));
+                    spentOutputs.Add(new TxOut(outputScriptPubKey, output.Value));
                 }
             }
 
@@ -58,53 +58,49 @@ public Response Handle(string requestId, ScriptVerifyParams parameters)
             return new Response
             {
                 Id = requestId,
-                Success = new { }
+                Result = true
             };
         }
         catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "inputIndex")
         {
             return new Response
             {
                 Id = requestId,
+                Result = null,
                 Error = new ErrorResponse
                 {
-                    Type = "ScriptVerify",
-                    Variant = "TxInputIndex"
+                    Code = new ErrorCode
+                    {
+                        Type = "btck_ScriptVerifyStatus",
+                        Member = "TxInputIndex"
+                    }
                 }
             };
         }
         catch (ScriptVerificationException ex)
         {
-            return new Response
+            // If status is OK, the script just failed verification (result: false)
+            // If status is not OK, it's an actual error condition
+            if (ex.Status == ScriptVerifyStatus.OK)
             {
-                Id = requestId,
-                Error = new ErrorResponse
+                return new Response
                 {
-                    Type = "ScriptVerify",
-                    Variant = MapScriptVerifyStatus(ex.Status)
-                }
-            };
-        }
-        catch (Exception
-#if DEBUG
-            ex
-#endif
-            )
-        {
-            // Log to stderr for debugging (can be disabled in production)
-#if DEBUG
-            Console.Error.WriteLine($"Exception: {ex.GetType().Name}: {ex.Message}");
-            Console.Error.WriteLine($"StackTrace: {ex.StackTrace}");
-#endif
+                    Id = requestId,
+                    Result = false
+                };
+            }
 
-            // Generic error for unexpected exceptions
             return new Response
             {
                 Id = requestId,
+                Result = null,
                 Error = new ErrorResponse
                 {
-                    Type = "ScriptVerify",
-                    Variant = "Invalid"
+                    Code = new ErrorCode
+                    {
+                        Type = "btck_ScriptVerifyStatus",
+                        Member = MapScriptVerifyStatus(ex.Status)
+                    }
                 }
             };
         }
@@ -132,9 +128,18 @@ private ScriptVerificationFlags ParseFlags(object? flags)
             {
                 return (ScriptVerificationFlags)jsonElement.GetUInt32();
             }
-            else if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.String)
+            else if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.Array)
             {
-                return ParseFlagString(jsonElement.GetString() ?? string.Empty);
+                // Handle array of string flags - combine them with OR
+                ScriptVerificationFlags combinedFlags = ScriptVerificationFlags.None;
+                foreach (var element in jsonElement.EnumerateArray())
+                {
+                    if (element.ValueKind == System.Text.Json.JsonValueKind.String)
+                    {
+                        combinedFlags |= ParseFlagString(element.GetString() ?? string.Empty);
+                    }
+                }
+                return combinedFlags;
             }
         }
 
@@ -152,18 +157,24 @@ private ScriptVerificationFlags ParseFlags(object? flags)
     /// </summary>
     private ScriptVerificationFlags ParseFlagString(string flagStr)
     {
+        // Handle btck_ prefixed format (e.g., "btck_ScriptVerificationFlags_WITNESS")
+        if (flagStr.StartsWith("btck_ScriptVerificationFlags_", StringComparison.OrdinalIgnoreCase))
+        {
+            flagStr = flagStr.Substring("btck_ScriptVerificationFlags_".Length);
+        }
+
         return flagStr.ToUpperInvariant() switch
         {
-            "VERIFY_NONE" or "NONE" => ScriptVerificationFlags.None,
-            "VERIFY_P2SH" or "P2SH" => ScriptVerificationFlags.P2SH,
-            "VERIFY_DERSIG" or "DERSIG" => ScriptVerificationFlags.DerSig,
-            "VERIFY_NULLDUMMY" or "NULLDUMMY" => ScriptVerificationFlags.NullDummy,
-            "VERIFY_CHECKLOCKTIMEVERIFY" or "CHECKLOCKTIMEVERIFY" => ScriptVerificationFlags.CheckLockTimeVerify,
-            "VERIFY_CHECKSEQUENCEVERIFY" or "CHECKSEQUENCEVERIFY" => ScriptVerificationFlags.CheckSequenceVerify,
-            "VERIFY_WITNESS" or "WITNESS" => ScriptVerificationFlags.Witness,
-            "VERIFY_TAPROOT" or "TAPROOT" => ScriptVerificationFlags.Taproot,
-            "VERIFY_ALL" or "ALL" => ScriptVerificationFlags.All,
-            "VERIFY_ALL_PRE_TAPROOT" or "ALL_PRE_TAPROOT" => ScriptVerificationFlags.AllPreTaproot,
+            "NONE" => ScriptVerificationFlags.None,
+            "P2SH" => ScriptVerificationFlags.P2SH,
+            "DERSIG" => ScriptVerificationFlags.DerSig,
+            "NULLDUMMY" => ScriptVerificationFlags.NullDummy,
+            "CHECKLOCKTIMEVERIFY" => ScriptVerificationFlags.CheckLockTimeVerify,
+            "CHECKSEQUENCEVERIFY" => ScriptVerificationFlags.CheckSequenceVerify,
+            "WITNESS" => ScriptVerificationFlags.Witness,
+            "TAPROOT" => ScriptVerificationFlags.Taproot,
+            "ALL" => ScriptVerificationFlags.All,
+            "ALL_PRE_TAPROOT" => ScriptVerificationFlags.AllPreTaproot,
             _ => throw new ArgumentException($"Unknown flag: {flagStr}")
         };
     }
@@ -175,12 +186,9 @@ private string MapScriptVerifyStatus(ScriptVerifyStatus status)
     {
         return status switch
         {
-            ScriptVerifyStatus.ERROR_TX_INPUT_INDEX => "TxInputIndex",
-            ScriptVerifyStatus.ERROR_INVALID_FLAGS => "InvalidFlags",
-            ScriptVerifyStatus.ERROR_INVALID_FLAGS_COMBINATION => "InvalidFlagsCombination",
-            ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_MISMATCH => "SpentOutputsMismatch",
-            ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_REQUIRED => "SpentOutputsRequired",
-            _ => "Invalid"
+            ScriptVerifyStatus.ERROR_INVALID_FLAGS_COMBINATION => "ERROR_INVALID_FLAGS_COMBINATION",
+            ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_REQUIRED => "ERROR_SPENT_OUTPUTS_REQUIRED",
+            _ => "ERROR_INVALID"
         };
     }
 }
diff --git a/tools/kernel-bindings-test-handler/Program.cs b/tools/kernel-bindings-test-handler/Program.cs
@@ -46,7 +46,10 @@ static async Task<int> Main(string[] args)
                             Id = "unknown",
                             Error = new ErrorResponse
                             {
-                                Type = "InvalidRequest"
+                                Code = new ErrorCode
+                                {
+                                    Type = "InvalidRequest"
+                                }
                             }
                         };
                     }
@@ -62,7 +65,10 @@ static async Task<int> Main(string[] args)
                         Id = "unknown",
                         Error = new ErrorResponse
                         {
-                            Type = "InvalidRequest"
+                            Code = new ErrorCode
+                            {
+                                Type = "InvalidRequest"
+                            }
                         }
                     };
                 }
@@ -91,42 +97,51 @@ private static Response HandleRequest(Request request, ScriptVerifyHandler scrip
         {
             switch (request.Method)
             {
-                case "script_pubkey.verify":
+                case "btck_script_pubkey_verify":
                     if (request.Params == null)
                     {
                         return new Response
                         {
                             Id = request.Id,
                             Error = new ErrorResponse
                             {
-                                Type = "InvalidParams"
+                                Code = new ErrorCode
+                                {
+                                    Type = "InvalidParams"
+                                }
                             }
                         };
                     }
 
-                    var scriptVerifyParams = JsonSerializer.Deserialize<ScriptVerifyParams>(request.Params.Value, jsonOptions);
+                    var btckScriptPubkeyVerifyParams = JsonSerializer.Deserialize<BtckScriptPubkeyVerifyParams>(request.Params.Value, jsonOptions);
 
-                    if (scriptVerifyParams == null)
+                    if (btckScriptPubkeyVerifyParams == null)
                     {
                         return new Response
                         {
                             Id = request.Id,
                             Error = new ErrorResponse
                             {
-                                Type = "InvalidParams"
+                                Code = new ErrorCode
+                                {
+                                    Type = "InvalidParams"
+                                }
                             }
                         };
                     }
 
-                    return scriptVerifyHandler.Handle(request.Id, scriptVerifyParams);
+                    return scriptVerifyHandler.Handle(request.Id, btckScriptPubkeyVerifyParams);
 
                 default:
                     return new Response
                     {
                         Id = request.Id,
                         Error = new ErrorResponse
                         {
-                            Type = "MethodNotFound"
+                            Code = new ErrorCode
+                            {
+                                Type = "MethodNotFound"
+                            }
                         }
                     };
             }
@@ -138,7 +153,10 @@ private static Response HandleRequest(Request request, ScriptVerifyHandler scrip
                 Id = request.Id,
                 Error = new ErrorResponse
                 {
-                    Type = "InternalError"
+                    Code = new ErrorCode
+                    {
+                        Type = "InternalError"
+                    }
                 }
             };
         }
diff --git a/tools/kernel-bindings-test-handler/Protocol/Request.cs b/tools/kernel-bindings-test-handler/Protocol/Request.cs
@@ -19,17 +19,17 @@ public class Request
 }
 
 /// <summary>
-/// Parameters for script_pubkey.verify method.
+/// Parameters for btck_script_pubkey_verify method.
 /// </summary>
-public class ScriptVerifyParams
+public class BtckScriptPubkeyVerifyParams
 {
-    [JsonPropertyName("script_pubkey_hex")]
+    [JsonPropertyName("script_pubkey")]
     public string ScriptPubKeyHex { get; set; } = string.Empty;
 
     [JsonPropertyName("amount")]
     public long Amount { get; set; }
 
-    [JsonPropertyName("tx_hex")]
+    [JsonPropertyName("tx_to")]
     public string TxHex { get; set; } = string.Empty;
 
     [JsonPropertyName("input_index")]
@@ -39,17 +39,17 @@ public class ScriptVerifyParams
     public List<SpentOutput>? SpentOutputs { get; set; }
 
     [JsonPropertyName("flags")]
-    public object? Flags { get; set; }  // Can be uint or string
+    public JsonElement? Flags { get; set; }  // Can be uint, or array
 }
 
 /// <summary>
 /// Represents a spent output.
 /// </summary>
 public class SpentOutput
 {
-    [JsonPropertyName("script_pubkey_hex")]
+    [JsonPropertyName("script_pubkey")]
     public string ScriptPubKeyHex { get; set; } = string.Empty;
 
     [JsonPropertyName("amount")]
-    public long Amount { get; set; }
+    public long Value { get; set; }
 }
diff --git a/tools/kernel-bindings-test-handler/Protocol/Response.cs b/tools/kernel-bindings-test-handler/Protocol/Response.cs
@@ -10,9 +10,9 @@ public class Response
     [JsonPropertyName("id")]
     public string Id { get; set; } = string.Empty;
 
-    [JsonPropertyName("success")]
+    [JsonPropertyName("result")]
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-    public object? Success { get; set; }
+    public object? Result { get; set; }
 
     [JsonPropertyName("error")]
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
@@ -23,11 +23,19 @@ public class Response
 /// Represents an error response.
 /// </summary>
 public class ErrorResponse
+{
+    [JsonPropertyName("code")]
+    public ErrorCode Code { get; set; } = new();
+}
+
+/// <summary>
+/// Represents an error code with type and member information.
+/// </summary>
+public class ErrorCode
 {
     [JsonPropertyName("type")]
     public string Type { get; set; } = string.Empty;
 
-    [JsonPropertyName("variant")]
-    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
-    public string? Variant { get; set; }
+    [JsonPropertyName("member")]
+    public string Member { get; set; } = string.Empty;
 }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public ScriptVerifyHandler(KernelContext context)`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// Handles a script verification request.`
`24`	`24`	`/// </summary>`
`25`		`- public Response Handle(string requestId, ScriptVerifyParams parameters)`
	`25`	`+ public Response Handle(string requestId, BtckScriptPubkeyVerifyParams parameters)`
`26`	`26`	`{`
`27`	`27`	`try`
`28`	`28`	`{`
`@@ -37,7 +37,7 @@ public Response Handle(string requestId, ScriptVerifyParams parameters)`
`37`	`37`	`foreach (var output in parameters.SpentOutputs)`
`38`	`38`	`{`
`39`	`39`	`var outputScriptPubKey = ScriptPubKey.FromHex(output.ScriptPubKeyHex);`
`40`		`- spentOutputs.Add(new TxOut(outputScriptPubKey, output.Amount));`
	`40`	`+ spentOutputs.Add(new TxOut(outputScriptPubKey, output.Value));`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`@@ -58,53 +58,49 @@ public Response Handle(string requestId, ScriptVerifyParams parameters)`
`58`	`58`	`return new Response`
`59`	`59`	`{`
`60`	`60`	`Id = requestId,`
`61`		`- Success = new { }`
	`61`	`+ Result = true`
`62`	`62`	`};`
`63`	`63`	`}`
`64`	`64`	`catch (ArgumentOutOfRangeException ex) when (ex.ParamName == "inputIndex")`
`65`	`65`	`{`
`66`	`66`	`return new Response`
`67`	`67`	`{`
`68`	`68`	`Id = requestId,`
	`69`	`+ Result = null,`
`69`	`70`	`Error = new ErrorResponse`
`70`	`71`	`{`
`71`		`- Type = "ScriptVerify",`
`72`		`- Variant = "TxInputIndex"`
	`72`	`+ Code = new ErrorCode`
	`73`	`+ {`
	`74`	`+ Type = "btck_ScriptVerifyStatus",`
	`75`	`+ Member = "TxInputIndex"`
	`76`	`+ }`
`73`	`77`	`}`
`74`	`78`	`};`
`75`	`79`	`}`
`76`	`80`	`catch (ScriptVerificationException ex)`
`77`	`81`	`{`
`78`		`- return new Response`
	`82`	`+ // If status is OK, the script just failed verification (result: false)`
	`83`	`+ // If status is not OK, it's an actual error condition`
	`84`	`+ if (ex.Status == ScriptVerifyStatus.OK)`
`79`	`85`	`{`
`80`		`- Id = requestId,`
`81`		`- Error = new ErrorResponse`
	`86`	`+ return new Response`
`82`	`87`	`{`
`83`		`- Type = "ScriptVerify",`
`84`		`- Variant = MapScriptVerifyStatus(ex.Status)`
`85`		`- }`
`86`		`- };`
`87`		`- }`
`88`		`- catch (Exception`
`89`		`-#if DEBUG`
`90`		`- ex`
`91`		`-#endif`
`92`		`- )`
`93`		`- {`
`94`		`- // Log to stderr for debugging (can be disabled in production)`
`95`		`-#if DEBUG`
`96`		`- Console.Error.WriteLine($"Exception: {ex.GetType().Name}: {ex.Message}");`
`97`		`- Console.Error.WriteLine($"StackTrace: {ex.StackTrace}");`
`98`		`-#endif`
	`88`	`+ Id = requestId,`
	`89`	`+ Result = false`
	`90`	`+ };`
	`91`	`+ }`
`99`	`92`
`100`		`- // Generic error for unexpected exceptions`
`101`	`93`	`return new Response`
`102`	`94`	`{`
`103`	`95`	`Id = requestId,`
	`96`	`+ Result = null,`
`104`	`97`	`Error = new ErrorResponse`
`105`	`98`	`{`
`106`		`- Type = "ScriptVerify",`
`107`		`- Variant = "Invalid"`
	`99`	`+ Code = new ErrorCode`
	`100`	`+ {`
	`101`	`+ Type = "btck_ScriptVerifyStatus",`
	`102`	`+ Member = MapScriptVerifyStatus(ex.Status)`
	`103`	`+ }`
`108`	`104`	`}`
`109`	`105`	`};`
`110`	`106`	`}`
`@@ -132,9 +128,18 @@ private ScriptVerificationFlags ParseFlags(object? flags)`
`132`	`128`	`{`
`133`	`129`	`return (ScriptVerificationFlags)jsonElement.GetUInt32();`
`134`	`130`	`}`
`135`		`- else if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.String)`
	`131`	`+ else if (jsonElement.ValueKind == System.Text.Json.JsonValueKind.Array)`
`136`	`132`	`{`
`137`		`- return ParseFlagString(jsonElement.GetString() ?? string.Empty);`
	`133`	`+ // Handle array of string flags - combine them with OR`
	`134`	`+ ScriptVerificationFlags combinedFlags = ScriptVerificationFlags.None;`
	`135`	`+ foreach (var element in jsonElement.EnumerateArray())`
	`136`	`+ {`
	`137`	`+ if (element.ValueKind == System.Text.Json.JsonValueKind.String)`
	`138`	`+ {`
	`139`	`+ combinedFlags \|= ParseFlagString(element.GetString() ?? string.Empty);`
	`140`	`+ }`
	`141`	`+ }`
	`142`	`+ return combinedFlags;`
`138`	`143`	`}`
`139`	`144`	`}`
`140`	`145`
`@@ -152,18 +157,24 @@ private ScriptVerificationFlags ParseFlags(object? flags)`
`152`	`157`	`/// </summary>`
`153`	`158`	`private ScriptVerificationFlags ParseFlagString(string flagStr)`
`154`	`159`	`{`
	`160`	`+ // Handle btck_ prefixed format (e.g., "btck_ScriptVerificationFlags_WITNESS")`
	`161`	`+ if (flagStr.StartsWith("btck_ScriptVerificationFlags_", StringComparison.OrdinalIgnoreCase))`
	`162`	`+ {`
	`163`	`+ flagStr = flagStr.Substring("btck_ScriptVerificationFlags_".Length);`
	`164`	`+ }`
	`165`	`+`
`155`	`166`	`return flagStr.ToUpperInvariant() switch`
`156`	`167`	`{`
`157`		`- "VERIFY_NONE" or "NONE" => ScriptVerificationFlags.None,`
`158`		`- "VERIFY_P2SH" or "P2SH" => ScriptVerificationFlags.P2SH,`
`159`		`- "VERIFY_DERSIG" or "DERSIG" => ScriptVerificationFlags.DerSig,`
`160`		`- "VERIFY_NULLDUMMY" or "NULLDUMMY" => ScriptVerificationFlags.NullDummy,`
`161`		`- "VERIFY_CHECKLOCKTIMEVERIFY" or "CHECKLOCKTIMEVERIFY" => ScriptVerificationFlags.CheckLockTimeVerify,`
`162`		`- "VERIFY_CHECKSEQUENCEVERIFY" or "CHECKSEQUENCEVERIFY" => ScriptVerificationFlags.CheckSequenceVerify,`
`163`		`- "VERIFY_WITNESS" or "WITNESS" => ScriptVerificationFlags.Witness,`
`164`		`- "VERIFY_TAPROOT" or "TAPROOT" => ScriptVerificationFlags.Taproot,`
`165`		`- "VERIFY_ALL" or "ALL" => ScriptVerificationFlags.All,`
`166`		`- "VERIFY_ALL_PRE_TAPROOT" or "ALL_PRE_TAPROOT" => ScriptVerificationFlags.AllPreTaproot,`
	`168`	`+ "NONE" => ScriptVerificationFlags.None,`
	`169`	`+ "P2SH" => ScriptVerificationFlags.P2SH,`
	`170`	`+ "DERSIG" => ScriptVerificationFlags.DerSig,`
	`171`	`+ "NULLDUMMY" => ScriptVerificationFlags.NullDummy,`
	`172`	`+ "CHECKLOCKTIMEVERIFY" => ScriptVerificationFlags.CheckLockTimeVerify,`
	`173`	`+ "CHECKSEQUENCEVERIFY" => ScriptVerificationFlags.CheckSequenceVerify,`
	`174`	`+ "WITNESS" => ScriptVerificationFlags.Witness,`
	`175`	`+ "TAPROOT" => ScriptVerificationFlags.Taproot,`
	`176`	`+ "ALL" => ScriptVerificationFlags.All,`
	`177`	`+ "ALL_PRE_TAPROOT" => ScriptVerificationFlags.AllPreTaproot,`
`167`	`178`	`_ => throw new ArgumentException($"Unknown flag: {flagStr}")`
`168`	`179`	`};`
`169`	`180`	`}`
`@@ -175,12 +186,9 @@ private string MapScriptVerifyStatus(ScriptVerifyStatus status)`
`175`	`186`	`{`
`176`	`187`	`return status switch`
`177`	`188`	`{`
`178`		`- ScriptVerifyStatus.ERROR_TX_INPUT_INDEX => "TxInputIndex",`
`179`		`- ScriptVerifyStatus.ERROR_INVALID_FLAGS => "InvalidFlags",`
`180`		`- ScriptVerifyStatus.ERROR_INVALID_FLAGS_COMBINATION => "InvalidFlagsCombination",`
`181`		`- ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_MISMATCH => "SpentOutputsMismatch",`
`182`		`- ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_REQUIRED => "SpentOutputsRequired",`
`183`		`- _ => "Invalid"`
	`189`	`+ ScriptVerifyStatus.ERROR_INVALID_FLAGS_COMBINATION => "ERROR_INVALID_FLAGS_COMBINATION",`
	`190`	`+ ScriptVerifyStatus.ERROR_SPENT_OUTPUTS_REQUIRED => "ERROR_SPENT_OUTPUTS_REQUIRED",`
	`191`	`+ _ => "ERROR_INVALID"`
`184`	`192`	`};`
`185`	`193`	`}`
`186`	`194`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,10 @@ static async Task<int> Main(string[] args)`
`46`	`46`	`Id = "unknown",`
`47`	`47`	`Error = new ErrorResponse`
`48`	`48`	`{`
`49`		`- Type = "InvalidRequest"`
	`49`	`+ Code = new ErrorCode`
	`50`	`+ {`
	`51`	`+ Type = "InvalidRequest"`
	`52`	`+ }`
`50`	`53`	`}`
`51`	`54`	`};`
`52`	`55`	`}`
`@@ -62,7 +65,10 @@ static async Task<int> Main(string[] args)`
`62`	`65`	`Id = "unknown",`
`63`	`66`	`Error = new ErrorResponse`
`64`	`67`	`{`
`65`		`- Type = "InvalidRequest"`
	`68`	`+ Code = new ErrorCode`
	`69`	`+ {`
	`70`	`+ Type = "InvalidRequest"`
	`71`	`+ }`
`66`	`72`	`}`
`67`	`73`	`};`
`68`	`74`	`}`
`@@ -91,42 +97,51 @@ private static Response HandleRequest(Request request, ScriptVerifyHandler scrip`
`91`	`97`	`{`
`92`	`98`	`switch (request.Method)`
`93`	`99`	`{`
`94`		`- case "script_pubkey.verify":`
	`100`	`+ case "btck_script_pubkey_verify":`
`95`	`101`	`if (request.Params == null)`
`96`	`102`	`{`
`97`	`103`	`return new Response`
`98`	`104`	`{`
`99`	`105`	`Id = request.Id,`
`100`	`106`	`Error = new ErrorResponse`
`101`	`107`	`{`
`102`		`- Type = "InvalidParams"`
	`108`	`+ Code = new ErrorCode`
	`109`	`+ {`
	`110`	`+ Type = "InvalidParams"`
	`111`	`+ }`
`103`	`112`	`}`
`104`	`113`	`};`
`105`	`114`	`}`
`106`	`115`
`107`		`- var scriptVerifyParams = JsonSerializer.Deserialize<ScriptVerifyParams>(request.Params.Value, jsonOptions);`
	`116`	`+ var btckScriptPubkeyVerifyParams = JsonSerializer.Deserialize<BtckScriptPubkeyVerifyParams>(request.Params.Value, jsonOptions);`
`108`	`117`
`109`		`- if (scriptVerifyParams == null)`
	`118`	`+ if (btckScriptPubkeyVerifyParams == null)`
`110`	`119`	`{`
`111`	`120`	`return new Response`
`112`	`121`	`{`
`113`	`122`	`Id = request.Id,`
`114`	`123`	`Error = new ErrorResponse`
`115`	`124`	`{`
`116`		`- Type = "InvalidParams"`
	`125`	`+ Code = new ErrorCode`
	`126`	`+ {`
	`127`	`+ Type = "InvalidParams"`
	`128`	`+ }`
`117`	`129`	`}`
`118`	`130`	`};`
`119`	`131`	`}`
`120`	`132`
`121`		`- return scriptVerifyHandler.Handle(request.Id, scriptVerifyParams);`
	`133`	`+ return scriptVerifyHandler.Handle(request.Id, btckScriptPubkeyVerifyParams);`
`122`	`134`
`123`	`135`	`default:`
`124`	`136`	`return new Response`
`125`	`137`	`{`
`126`	`138`	`Id = request.Id,`
`127`	`139`	`Error = new ErrorResponse`
`128`	`140`	`{`
`129`		`- Type = "MethodNotFound"`
	`141`	`+ Code = new ErrorCode`
	`142`	`+ {`
	`143`	`+ Type = "MethodNotFound"`
	`144`	`+ }`
`130`	`145`	`}`
`131`	`146`	`};`
`132`	`147`	`}`
`@@ -138,7 +153,10 @@ private static Response HandleRequest(Request request, ScriptVerifyHandler scrip`
`138`	`153`	`Id = request.Id,`
`139`	`154`	`Error = new ErrorResponse`
`140`	`155`	`{`
`141`		`- Type = "InternalError"`
	`156`	`+ Code = new ErrorCode`
	`157`	`+ {`
	`158`	`+ Type = "InternalError"`
	`159`	`+ }`
`142`	`160`	`}`
`143`	`161`	`};`
`144`	`162`	`}`