Cast JsonRPC to Json (#51)

* Cast JsonRPC to Json

JsonRpcStruct params was type Record<string, unknown> | unknown[], but
in other parts of the code we use Json to denote such structures.
unknown is not castable to Json because of undefined and classes.
This commit solves the compatibillity issue with other parts of the code

* PR review changes

* Nicer JSON validation msg

* Fix lint

src/json.test.ts

@@ -1,4 +1,5 @@
 import * as superstructModule from 'superstruct';
+import { validate } from 'superstruct';
 import {
   ARRAY_OF_DIFFRENT_KINDS_OF_NUMBERS,
   COMPLEX_OBJECT,
@@ -13,26 +14,38 @@ import {
   NON_SERIALIZABLE_NESTED_OBJECT,
 } from './__fixtures__';
 import {
+  assert,
+  assertIsJsonRpcError,
   assertIsJsonRpcFailure,
   assertIsJsonRpcNotification,
   assertIsJsonRpcRequest,
   assertIsJsonRpcResponse,
   assertIsJsonRpcSuccess,
   assertIsPendingJsonRpcResponse,
   getJsonRpcIdValidator,
+  isJsonRpcError,
   isJsonRpcFailure,
   isJsonRpcNotification,
   isJsonRpcRequest,
   isJsonRpcResponse,
   isJsonRpcSuccess,
   isPendingJsonRpcResponse,
   isValidJson,
+  JsonStruct,
   validateJsonAndGetSize,
-  isJsonRpcError,
-  assertIsJsonRpcError,
 } from '.';
 
 describe('json', () => {
+  describe('JsonStruct', () => {
+    it('returns error message', () => {
+      const [error] = validate(undefined, JsonStruct);
+      assert(error !== undefined);
+      expect(error.message).toStrictEqual(
+        'Expected a valid JSON-serializable value',
+      );
+    });
+  });
+
   // TODO: Make this test suite exhaustive.
   // The current implementation is guaranteed to be correct, but in the future
   // we may opt for a bespoke implementation that is more performant, but may
@@ -425,11 +438,11 @@ describe('json', () => {
     };
 
     const validateAll = (
-      validate: ReturnType<typeof getJsonRpcIdValidator>,
+      validator: ReturnType<typeof getJsonRpcIdValidator>,
       inputs: ReturnType<typeof getInputs>,
     ) => {
       for (const input of Object.values(inputs)) {
-        expect(validate(input.value)).toStrictEqual(input.expected);
+        expect(validator(input.value)).toStrictEqual(input.expected);
       }
     };
 

src/json.ts

@@ -10,22 +10,26 @@ import {
   object,
   omit,
   optional,
+  record,
   string,
   Struct,
   union,
   unknown,
 } from 'superstruct';
+import { AssertionErrorConstructor, assertStruct } from './assert';
 import {
   calculateNumberSize,
   calculateStringSize,
   isPlainObject,
   JsonSize,
 } from './misc';
-import { AssertionErrorConstructor, assertStruct } from './assert';
 
 export const JsonStruct = define<Json>('Json', (value) => {
   const [isValid] = validateJsonAndGetSize(value, true);
-  return isValid;
+  if (!isValid) {
+    return 'Expected a valid JSON-serializable value';
+  }
+  return true;
 });
 
 /**
@@ -99,8 +103,9 @@ export type JsonRpcError = OptionalField<
   'data'
 >;
 
-export const JsonRpcParamsStruct = optional(union([object(), array()]));
-
+export const JsonRpcParamsStruct = optional(
+  union([record(string(), JsonStruct), array(JsonStruct)]),
+);
 export type JsonRpcParams = Infer<typeof JsonRpcParamsStruct>;
 
 export const JsonRpcRequestStruct = object({