Added schema validation

borsh-ts/buffer.ts

@@ -1,4 +1,4 @@
-import { NumberType } from './types';
+import { IntegerType } from './types';
 
 export class EncodeBuffer {
     offset = 0;
@@ -22,7 +22,7 @@ export class EncodeBuffer {
         return new Uint8Array(this.buffer).slice(0, this.offset);
     }
 
-    store_value(value: number, type: NumberType): void {
+    store_value(value: number, type: IntegerType): void {
         const size = parseInt(type.substring(1)) / 8;
         this.resize_if_necessary(size);
 
@@ -76,7 +76,7 @@ export class DecodeBuffer {
         this.view = new DataView(this.buffer);
     }
 
-    consume_value(type: NumberType): number {
+    consume_value(type: IntegerType): number {
         const size = parseInt(type.substring(1)) / 8;
         let ret: number;
 

borsh-ts/deserialize.ts

@@ -1,4 +1,5 @@
-import { ArrayType, DecodeTypes, MapType, NumberType, OptionType, Schema, SetType, StructType, numbers } from './types';
+import { ArrayType, DecodeTypes, MapType, IntegerType, OptionType, Schema, SetType, StructType, integers } from './types';
+import * as utils from './utils';
 import { DecodeBuffer } from './buffer';
 import BN from 'bn.js';
 
@@ -10,9 +11,13 @@ export class BorshDeserializer {
     }
 
     decode(schema: Schema, classType?: ObjectConstructor): DecodeTypes {
+        utils.validate_schema(schema);
+        return this.decode_value(schema, classType);
+    }
 
+    decode_value(schema: Schema, classType?: ObjectConstructor): DecodeTypes {
         if (typeof schema === 'string') {
-            if (numbers.includes(schema)) return this.decode_integer(schema);
+            if (integers.includes(schema)) return this.decode_integer(schema);
             if (schema === 'string') return this.decode_string();
             if (schema === 'bool') return this.decode_boolean();
         }
@@ -28,7 +33,7 @@ export class BorshDeserializer {
         throw new Error(`Unsupported type: ${schema}`);
     }
 
-    decode_integer(schema: NumberType): number | BN {
+    decode_integer(schema: IntegerType): number | BN {
         const size: number = parseInt(schema.substring(1));
 
         if (size <= 32 || schema == 'f64') {
@@ -70,7 +75,7 @@ export class BorshDeserializer {
     decode_option(schema: OptionType): DecodeTypes {
         const option = this.buffer.consume_value('u8');
         if (option === 1) {
-            return this.decode(schema.option);
+            return this.decode_value(schema.option);
         }
         if (option !== 0) {
             throw new Error(`Invalid option ${option}`);
@@ -83,7 +88,7 @@ export class BorshDeserializer {
         const len = schema.array.len ? schema.array.len : this.decode_integer('u32') as number;
 
         for (let i = 0; i < len; ++i) {
-            result.push(this.decode(schema.array.type));
+            result.push(this.decode_value(schema.array.type));
         }
 
         return result;
@@ -93,7 +98,7 @@ export class BorshDeserializer {
         const len = this.decode_integer('u32') as number;
         const result = new Set();
         for (let i = 0; i < len; ++i) {
-            result.add(this.decode(schema.set));
+            result.add(this.decode_value(schema.set));
         }
         return result;
     }
@@ -102,8 +107,8 @@ export class BorshDeserializer {
         const len = this.decode_integer('u32') as number;
         const result = new Map();
         for (let i = 0; i < len; ++i) {
-            const key = this.decode(schema.map.key);
-            const value = this.decode(schema.map.value);
+            const key = this.decode_value(schema.map.key);
+            const value = this.decode_value(schema.map.value);
             result.set(key, value);
         }
         return result;
@@ -112,7 +117,7 @@ export class BorshDeserializer {
     decode_struct(schema: StructType, classType?: ObjectConstructor): object {
         const result = {};
         for (const key in schema.struct) {
-            result[key] = this.decode(schema.struct[key]);
+            result[key] = this.decode_value(schema.struct[key]);
         }
         return classType ? new classType(result) : result;
     }

borsh-ts/serialize.ts

@@ -1,4 +1,4 @@
-import { ArrayType, MapType, NumberType, OptionType, Schema, SetType, StructType, numbers } from './types';
+import { ArrayType, MapType, IntegerType, OptionType, Schema, SetType, StructType, integers } from './types';
 import { EncodeBuffer } from './buffer';
 import BN from 'bn.js';
 import * as utils from './utils';
@@ -7,24 +7,28 @@ export class BorshSerializer {
     encoded: EncodeBuffer = new EncodeBuffer();
 
     encode(value: unknown, schema: Schema): Uint8Array {
+        utils.validate_schema(schema);
+        this.encode_value(value, schema);
+        return this.encoded.get_used_buffer();
+    }
+
+    encode_value(value: unknown, schema: Schema): void {
         if (typeof schema === 'string') {
-            if (numbers.includes(schema)) this.encode_integer(value, schema);
-            if (schema === 'string') this.encode_string(value);
-            if (schema === 'bool') this.encode_boolean(value);
+            if (integers.includes(schema)) return this.encode_integer(value, schema);
+            if (schema === 'string') return this.encode_string(value);
+            if (schema === 'bool') return this.encode_boolean(value);
         }
 
         if (typeof schema === 'object') {
-            if ('option' in schema) this.encode_option(value, schema as OptionType);
-            if ('array' in schema) this.encode_array(value, schema as ArrayType);
-            if ('set' in schema) this.encode_set(value, schema as SetType);
-            if ('map' in schema) this.encode_map(value, schema as MapType);
-            if ('struct' in schema) this.encode_struct(value, schema as StructType);
+            if ('option' in schema) return this.encode_option(value, schema as OptionType);
+            if ('array' in schema) return this.encode_array(value, schema as ArrayType);
+            if ('set' in schema) return this.encode_set(value, schema as SetType);
+            if ('map' in schema) return this.encode_map(value, schema as MapType);
+            if ('struct' in schema) return this.encode_struct(value, schema as StructType);
         }
-
-        return this.encoded.get_used_buffer();
     }
 
-    encode_integer(value: unknown, schema: NumberType): void {
+    encode_integer(value: unknown, schema: IntegerType): void {
         const size: number = parseInt(schema.substring(1));
 
         if (size <= 32 || schema == 'f64') {
@@ -76,7 +80,7 @@ export class BorshSerializer {
             this.encoded.store_value(0, 'u8');
         } else {
             this.encoded.store_value(1, 'u8');
-            this.encode(value, schema.option);
+            this.encode_value(value, schema.option);
         }
     }
 
@@ -96,7 +100,7 @@ export class BorshSerializer {
 
         // array values
         for (let i = 0; i < value.length; i++) {
-            this.encode(value[i], schema.array.type);
+            this.encode_value(value[i], schema.array.type);
         }
     }
 
@@ -123,7 +127,7 @@ export class BorshSerializer {
 
         // set values
         for (const value of values) {
-            this.encode(value, schema.set);
+            this.encode_value(value, schema.set);
         }
     }
 
@@ -138,16 +142,16 @@ export class BorshSerializer {
 
         // store key/values
         for (const key of keys) {
-            this.encode(key, schema.map.key);
-            this.encode(isMap ? value.get(key) : value[key], schema.map.value);
+            this.encode_value(key, schema.map.key);
+            this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);
         }
     }
 
     encode_struct(value: unknown, schema: StructType): void {
         utils.expect_type(value, 'object');
 
         for (const key of Object.keys(value)) {
-            this.encode(value[key], schema.struct[key]);
+            this.encode_value(value[key], schema.struct[key]);
         }
     }
 }

borsh-ts/types.ts

@@ -1,8 +1,8 @@
 import BN from 'bn.js';
 
-export const numbers = ['u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128', 'f32', 'f64'];
+export const integers = ['u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128', 'f32', 'f64'];
 
-export type NumberType = typeof numbers[number];
+export type IntegerType = typeof integers[number];
 export type BoolType = 'bool';
 export type StringType = 'string';
 
@@ -11,7 +11,7 @@ export type ArrayType = { array: { type: Schema, len?: number } };
 export type SetType = { set: Schema };
 export type MapType = { map: { key: Schema, value: Schema } };
 export type StructType = { struct: { [key: string]: Schema } };
-export type Schema = NumberType | StringType | ArrayType | SetType | MapType | StructType;
+export type Schema = IntegerType | StringType | ArrayType | SetType | MapType | StructType;
 
 // returned
 export type DecodeTypes = number | BN | string | boolean | Array<any> | ArrayBuffer | Map<any, any> | Set<any> | object | null;

borsh-ts/utils.ts

@@ -1,4 +1,5 @@
 import BN from 'bn.js';
+import { Schema, integers } from './types';
 
 export function isArrayLike(value: unknown): boolean {
     // source: https://stackoverflow.com/questions/24048547/checking-if-an-object-is-array-like
@@ -32,4 +33,50 @@ export function expect_same_size(length: number, expected: number): void {
     if (length !== expected) {
         throw new Error(`Array length ${length} does not match schema length ${expected}`);
     }
+}
+
+// Validate Schema
+const VALID_STRING_TYPES = integers.concat(['bool', 'string']);
+const VALID_OBJECT_KEYS = ['option', 'array', 'set', 'map', 'struct'];
+
+export function validate_schema(schema: Schema): void {
+    if (typeof (schema) === 'string' && VALID_STRING_TYPES.includes(schema)) {
+        return;
+    }
+
+    if (typeof (schema) === 'object') {
+        const keys = Object.keys(schema);
+
+        if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {
+            const key = keys[0];
+
+            if(key === 'option') return validate_schema(schema[key]);
+            if(key === 'array') return validate_array_schema(schema[key]);
+            if(key === 'set') return validate_schema(schema[key]);
+            if(key === 'map') return validate_map_schema(schema[key]);
+            if(key === 'struct') return validate_struct_schema(schema[key]);
+        }
+    }
+    throw new Error(`Invalid schema: ${schema}`);
+}
+
+
+function validate_array_schema(schema: {type: Schema, len?: number}): void {
+    if (schema.len && typeof schema.len !== 'number') {
+        throw new Error(`Invalid schema: ${schema}`);
+    }
+    return validate_schema(schema.type);
+}
+
+function validate_map_schema(schema: {key: Schema, value: Schema}): void {
+    validate_schema(schema.key);
+    validate_schema(schema.value);
+}
+
+function validate_struct_schema(schema: {[key: string]: Schema}): void {
+    if(typeof schema !== 'object') throw new Error(`Invalid schema: ${schema}`);
+
+    for (const key in schema) {
+        validate_schema(schema[key]);
+    }
 }

lib/buffer.d.ts

@@ -1,12 +1,12 @@
-import { NumberType } from './types';
+import { IntegerType } from './types';
 export declare class EncodeBuffer {
     offset: number;
     buffer_size: number;
     buffer: ArrayBuffer;
     view: DataView;
     resize_if_necessary(needed_space: number): void;
     get_used_buffer(): Uint8Array;
-    store_value(value: number, type: NumberType): void;
+    store_value(value: number, type: IntegerType): void;
     store_bytes(from: Uint8Array): void;
 }
 export declare class DecodeBuffer {
@@ -15,6 +15,6 @@ export declare class DecodeBuffer {
     buffer: ArrayBuffer;
     view: DataView;
     constructor(buf: Uint8Array);
-    consume_value(type: NumberType): number;
+    consume_value(type: IntegerType): number;
     consume_bytes(size: number): ArrayBuffer;
 }

lib/deserialize.d.ts

@@ -1,11 +1,12 @@
-import { ArrayType, DecodeTypes, MapType, NumberType, OptionType, Schema, SetType, StructType } from './types';
+import { ArrayType, DecodeTypes, MapType, IntegerType, OptionType, Schema, SetType, StructType } from './types';
 import { DecodeBuffer } from './buffer';
 import BN from 'bn.js';
 export declare class BorshDeserializer {
     buffer: DecodeBuffer;
     constructor(bufferArray: Uint8Array);
     decode(schema: Schema, classType?: ObjectConstructor): DecodeTypes;
-    decode_integer(schema: NumberType): number | BN;
+    decode_value(schema: Schema, classType?: ObjectConstructor): DecodeTypes;
+    decode_integer(schema: IntegerType): number | BN;
     decode_bigint(size: number): BN;
     decode_string(): string;
     decode_boolean(): boolean;