From 982ae3858f2d1d0d2bb7a44718975b02ad75eea7 Mon Sep 17 00:00:00 2001
From: Andrei Bancioiu <andrei.bancioiu@gmail.com>
Date: Fri, 25 Mar 2022 12:48:18 +0200
Subject: [PATCH] Hardcode class names for classes within erdjs' typesystem.
 Tests for minified JS, as well.

---
 Makefile                                      |   5 +-
 browser-tests/index.html                      |   5 +
 src/reflection.ts                             |  10 --
 src/smartcontracts/argSerializer.ts           |  12 +-
 src/smartcontracts/typesystem/abiRegistry.ts  |   4 +-
 src/smartcontracts/typesystem/address.ts      |  11 ++
 src/smartcontracts/typesystem/algebraic.ts    |  11 ++
 src/smartcontracts/typesystem/boolean.ts      |  11 ++
 src/smartcontracts/typesystem/bytes.ts        |  12 +-
 src/smartcontracts/typesystem/composite.ts    |  11 ++
 src/smartcontracts/typesystem/enum.ts         |  10 ++
 src/smartcontracts/typesystem/generic.ts      |  26 +++-
 src/smartcontracts/typesystem/genericArray.ts |  10 ++
 src/smartcontracts/typesystem/h256.ts         |  12 +-
 src/smartcontracts/typesystem/matchers.ts     |  60 ++++----
 src/smartcontracts/typesystem/nothing.ts      |  12 ++
 src/smartcontracts/typesystem/numerical.ts    | 131 ++++++++++++++++++
 src/smartcontracts/typesystem/string.ts       |  11 ++
 src/smartcontracts/typesystem/struct.ts       |  10 ++
 .../typesystem/tokenIdentifier.ts             |  12 +-
 src/smartcontracts/typesystem/tuple.ts        |  12 ++
 src/smartcontracts/typesystem/typeMapper.ts   |   4 +-
 src/smartcontracts/typesystem/types.spec.ts   |  12 +-
 src/smartcontracts/typesystem/types.ts        |  84 ++++++++---
 src/smartcontracts/typesystem/variadic.ts     |  11 ++
 25 files changed, 433 insertions(+), 76 deletions(-)

diff --git a/Makefile b/Makefile
index 277f6c422..ad7c864c3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,10 +1,13 @@
 .PHONY: clean browser-tests
 
-browser-tests: out-browser-tests/erdjs-tests-unit.js out-browser-tests/erdjs-tests-localnet.js out-browser-tests/erdjs-tests-devnet.js out-browser-tests/erdjs-tests-testnet.js out-browser-tests/erdjs-tests-mainnet.js
+browser-tests: out-browser-tests/erdjs-tests-unit.js out-browser-tests/erdjs-tests-unit-min.js out-browser-tests/erdjs-tests-localnet.js out-browser-tests/erdjs-tests-devnet.js out-browser-tests/erdjs-tests-testnet.js out-browser-tests/erdjs-tests-mainnet.js
 
 out-browser-tests/erdjs-tests-unit.js: out-tests
 	npx browserify $(shell find out-tests -type f -name '*.js' ! -name '*.net.spec.*') --require buffer/:buffer -o out-browser-tests/erdjs-tests-unit.js --standalone erdjs-tests -p esmify
 
+out-browser-tests/erdjs-tests-unit-min.js: out-tests
+	npx browserify $(shell find out-tests -type f -name '*.js' ! -name '*.net.spec.*') --require buffer/:buffer -o out-browser-tests/erdjs-tests-unit-min.js --standalone erdjs-tests -p esmify -p tinyify
+
 out-browser-tests/erdjs-tests-localnet.js: out-tests
 	npx browserify $(shell find out-tests -type f -name '*.js' ! -name '*.spec.*') $(shell find out-tests -type f -name '*.local.net.spec.js') --require buffer/:buffer -o out-browser-tests/erdjs-tests-localnet.js --standalone erdjs-tests -p esmify
 
diff --git a/browser-tests/index.html b/browser-tests/index.html
index d2ae5277a..6c69f310f 100644
--- a/browser-tests/index.html
+++ b/browser-tests/index.html
@@ -18,6 +18,11 @@
                             Unit tests
                         </button>
                     </li>
+                    <li class="list-group-item">
+                        <button class="btn btn-link" onclick="runTests('/out-browser-tests/erdjs-tests-unit-min.js')">
+                            Unit tests (minified code)
+                        </button>
+                    </li>
                     <li class="list-group-item">
                         <button class="btn btn-link" onclick="runTests('/out-browser-tests/erdjs-tests-localnet.js')">
                             Integration tests - local testnet
diff --git a/src/reflection.ts b/src/reflection.ts
index 5e7a357e9..836ffdb03 100644
--- a/src/reflection.ts
+++ b/src/reflection.ts
@@ -1,13 +1,3 @@
-export function hasJavascriptConstructor(obj: Object, javascriptConstructorName: string): boolean {
-    return obj.constructor.name == javascriptConstructorName;
-}
-
-export function getJavascriptConstructorsNamesInHierarchy(obj: Object, filter: (prototype: any) => boolean): string[] {
-    let prototypes = getJavascriptPrototypesInHierarchy(obj, filter);
-    let constructorNames = prototypes.map(prototype => prototype.constructor.name);
-    return constructorNames;
-}
-
 export function getJavascriptPrototypesInHierarchy(obj: Object, filter: (prototype: any) => boolean): Object[] {
     let prototypes: Object[] = [];
     let prototype: any = Object.getPrototypeOf(obj);
diff --git a/src/smartcontracts/argSerializer.ts b/src/smartcontracts/argSerializer.ts
index 3659221f3..aa6a02e12 100644
--- a/src/smartcontracts/argSerializer.ts
+++ b/src/smartcontracts/argSerializer.ts
@@ -52,10 +52,10 @@ export class ArgSerializer {
         function readValue(type: Type): TypedValue {
             // TODO: Use matchers.
 
-            if (type.hasJavascriptConstructor(OptionalType.name)) {
+            if (type.hasExactClass(OptionalType.ClassName)) {
                 let typedValue = readValue(type.getFirstTypeParameter());
                 return new OptionalValue(type, typedValue);
-            } else if (type.hasJavascriptConstructor(VariadicType.name)) {
+            } else if (type.hasExactClass(VariadicType.ClassName)) {
                 let typedValues = [];
 
                 while (!hasReachedTheEnd()) {
@@ -63,7 +63,7 @@ export class ArgSerializer {
                 }
 
                 return new VariadicValue(type, typedValues);
-            } else if (type.hasJavascriptConstructor(CompositeType.name)) {
+            } else if (type.hasExactClass(CompositeType.ClassName)) {
                 let typedValues = [];
 
                 for (const typeParameter of type.getTypeParameters()) {
@@ -132,17 +132,17 @@ export class ArgSerializer {
         function handleValue(value: TypedValue): void {
             // TODO: Use matchers.
 
-            if (value.hasJavascriptConstructor(OptionalValue.name)) {
+            if (value.hasExactClass(OptionalValue.ClassName)) {
                 let valueAsOptional = <OptionalValue>value;
                 if (valueAsOptional.isSet()) {
                     handleValue(valueAsOptional.getTypedValue());
                 }
-            } else if (value.hasJavascriptConstructor(VariadicValue.name)) {
+            } else if (value.hasExactClass(VariadicValue.ClassName)) {
                 let valueAsVariadic = <VariadicValue>value;
                 for (const item of valueAsVariadic.getItems()) {
                     handleValue(item);
                 }
-            } else if (value.hasJavascriptConstructor(CompositeValue.name)) {
+            } else if (value.hasExactClass(CompositeValue.ClassName)) {
                 let valueAsComposite = <CompositeValue>value;
                 for (const item of valueAsComposite.getItems()) {
                     handleValue(item);
diff --git a/src/smartcontracts/typesystem/abiRegistry.ts b/src/smartcontracts/typesystem/abiRegistry.ts
index 7d81b1b23..aae72569c 100644
--- a/src/smartcontracts/typesystem/abiRegistry.ts
+++ b/src/smartcontracts/typesystem/abiRegistry.ts
@@ -76,7 +76,7 @@ export class AbiRegistry {
         return names.map((name) => this.getInterface(name));
     }
     getStruct(name: string): StructType {
-        let result = this.customTypes.find((e) => e.getName() == name && e.hasJavascriptConstructor(StructType.name));
+        let result = this.customTypes.find((e) => e.getName() == name && e.hasExactClass(StructType.ClassName));
         guardValueIsSetWithMessage(`struct [${name}] not found`, result);
         return <StructType>result!;
     }
@@ -84,7 +84,7 @@ export class AbiRegistry {
         return names.map((name) => this.getStruct(name));
     }
     getEnum(name: string): EnumType {
-        let result = this.customTypes.find((e) => e.getName() == name && e.hasJavascriptConstructor(EnumType.name));
+        let result = this.customTypes.find((e) => e.getName() == name && e.hasExactClass(EnumType.ClassName));
         guardValueIsSetWithMessage(`enum [${name}] not found`, result);
         return <EnumType>result!;
     }
diff --git a/src/smartcontracts/typesystem/address.ts b/src/smartcontracts/typesystem/address.ts
index b42256839..54bea43bc 100644
--- a/src/smartcontracts/typesystem/address.ts
+++ b/src/smartcontracts/typesystem/address.ts
@@ -2,15 +2,22 @@ import { Address } from "../../address";
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class AddressType extends PrimitiveType {
+    static ClassName = "AddressType";
+
     constructor() {
         super("Address");
     }
+
+    getClassName(): string {
+        return AddressType.ClassName;
+    }
 }
 
 /**
  * An address fed to or fetched from a Smart Contract contract, as an immutable abstraction.
  */
 export class AddressValue extends PrimitiveValue {
+    static ClassName = "AddressValue";
     private readonly value: Address;
 
     constructor(value: Address) {
@@ -18,6 +25,10 @@ export class AddressValue extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return AddressValue.ClassName;
+    }
+
     /**
      * Returns whether two objects have the same value.
      * 
diff --git a/src/smartcontracts/typesystem/algebraic.ts b/src/smartcontracts/typesystem/algebraic.ts
index 14bc3d031..b9da9d660 100644
--- a/src/smartcontracts/typesystem/algebraic.ts
+++ b/src/smartcontracts/typesystem/algebraic.ts
@@ -5,12 +5,19 @@ import { Type, TypeCardinality, TypedValue } from "./types";
  * An optional is an algebraic type. It holds zero or one values.
  */
 export class OptionalType extends Type {
+    static ClassName = "OptionalType";
+
     constructor(typeParameter: Type) {
         super("Optional", [typeParameter], TypeCardinality.variable(1));
     }
+
+    getClassName(): string {
+        return OptionalType.ClassName;
+    }
 }
 
 export class OptionalValue extends TypedValue {
+    static ClassName = "OptionalValue";
     private readonly value: TypedValue | null;
 
     constructor(type: OptionalType, value: TypedValue | null = null) {
@@ -21,6 +28,10 @@ export class OptionalValue extends TypedValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return OptionalValue.ClassName;
+    }
+
     isSet(): boolean {
         return this.value ? true : false;
     }
diff --git a/src/smartcontracts/typesystem/boolean.ts b/src/smartcontracts/typesystem/boolean.ts
index 7d37d90b8..78b68dac1 100644
--- a/src/smartcontracts/typesystem/boolean.ts
+++ b/src/smartcontracts/typesystem/boolean.ts
@@ -1,15 +1,22 @@
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class BooleanType extends PrimitiveType {
+    static ClassName = "BooleanType";
+
     constructor() {
         super("bool");
     }
+
+    getClassName(): string {
+        return BooleanType.ClassName;
+    }
 }
 
 /**
  * A boolean value fed to or fetched from a Smart Contract contract, as an immutable abstraction.
  */
 export class BooleanValue extends PrimitiveValue {
+    static ClassName = "BooleanValue";
     private readonly value: boolean;
 
     constructor(value: boolean) {
@@ -17,6 +24,10 @@ export class BooleanValue extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return BooleanValue.ClassName;
+    }
+
     /**
      * Returns whether two objects have the same value.
      * 
diff --git a/src/smartcontracts/typesystem/bytes.ts b/src/smartcontracts/typesystem/bytes.ts
index 35b36a60a..2133fc1f4 100644
--- a/src/smartcontracts/typesystem/bytes.ts
+++ b/src/smartcontracts/typesystem/bytes.ts
@@ -1,13 +1,19 @@
-import * as errors from "../../errors";
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class BytesType extends PrimitiveType {
+    static ClassName = "BytesType";
+
     constructor() {
         super("bytes");
     }
+
+    getClassName(): string {
+        return BytesType.ClassName;
+    }
 }
 
 export class BytesValue extends PrimitiveValue {
+    static ClassName = "BytesValue";
     private readonly value: Buffer;
 
     constructor(value: Buffer) {
@@ -15,6 +21,10 @@ export class BytesValue extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return BytesValue.ClassName;
+    }
+
     /**
      * Creates a BytesValue from a utf-8 string.
      */
diff --git a/src/smartcontracts/typesystem/composite.ts b/src/smartcontracts/typesystem/composite.ts
index 6efbee42d..1ded3985d 100644
--- a/src/smartcontracts/typesystem/composite.ts
+++ b/src/smartcontracts/typesystem/composite.ts
@@ -2,12 +2,19 @@ import { guardLength } from "../../utils";
 import { Type, TypeCardinality, TypedValue } from "./types";
 
 export class CompositeType extends Type {
+    static ClassName = "CompositeType";
+
     constructor(...typeParameters: Type[]) {
         super("Composite", typeParameters, TypeCardinality.variable(typeParameters.length));
     }
+
+    getClassName(): string {
+        return CompositeType.ClassName;
+    }
 }
 
 export class CompositeValue extends TypedValue {
+    static ClassName = "CompositeValue";
     private readonly items: TypedValue[];
 
     constructor(type: CompositeType, items: TypedValue[]) {
@@ -20,6 +27,10 @@ export class CompositeValue extends TypedValue {
         this.items = items;
     }
 
+    getClassName(): string {
+        return CompositeValue.ClassName;
+    }
+
     static fromItems(...items: TypedValue[]): CompositeValue {
         let typeParameters = items.map(value => value.getType());
         let type = new CompositeType(...typeParameters);
diff --git a/src/smartcontracts/typesystem/enum.ts b/src/smartcontracts/typesystem/enum.ts
index 1d1e20b14..4cb76cff8 100644
--- a/src/smartcontracts/typesystem/enum.ts
+++ b/src/smartcontracts/typesystem/enum.ts
@@ -5,6 +5,7 @@ import { CustomType, TypedValue } from "./types";
 const SimpleEnumMaxDiscriminant = 256;
 
 export class EnumType extends CustomType {
+    static ClassName = "EnumType";
     readonly variants: EnumVariantDefinition[] = [];
 
     constructor(name: string, variants: EnumVariantDefinition[]) {
@@ -12,6 +13,10 @@ export class EnumType extends CustomType {
         this.variants = variants;
     }
 
+    getClassName(): string {
+        return EnumType.ClassName;
+    }
+
     static fromJSON(json: { name: string; variants: any[] }): EnumType {
         let variants = (json.variants || []).map((variant) => EnumVariantDefinition.fromJSON(variant));
         return new EnumType(json.name, variants);
@@ -57,6 +62,7 @@ export class EnumVariantDefinition {
 }
 
 export class EnumValue extends TypedValue {
+    static ClassName = "EnumValue";
     readonly name: string;
     readonly discriminant: number;
     private readonly fields: Field[] = [];
@@ -71,6 +77,10 @@ export class EnumValue extends TypedValue {
         Fields.checkTyping(this.fields, definitions);
     }
 
+    getClassName(): string {
+        return EnumValue.ClassName;
+    }
+
     /**
      * Utility (named constructor) to create a simple (i.e. without fields) enum value.
      */
diff --git a/src/smartcontracts/typesystem/generic.ts b/src/smartcontracts/typesystem/generic.ts
index 264571561..9409d4163 100644
--- a/src/smartcontracts/typesystem/generic.ts
+++ b/src/smartcontracts/typesystem/generic.ts
@@ -4,30 +4,43 @@ import { Type, TypedValue, NullType, TypePlaceholder } from "./types";
 
 // TODO: Move to a new file, "genericOption.ts"
 export class OptionType extends Type {
+    static ClassName = "OptionType";
+
     constructor(typeParameter: Type) {
         super("Option", [typeParameter]);
     }
 
+    getClassName(): string {
+        return OptionType.ClassName;
+    }
+
     isAssignableFrom(type: Type): boolean {
-        if (!(type.hasJavascriptConstructor(OptionType.name))) {
+        if (!(type.hasExactClass(OptionType.ClassName))) {
             return false;
         }
 
         let invariantTypeParameters = this.getFirstTypeParameter().equals(type.getFirstTypeParameter());
-        let fakeCovarianceToNull = type.getFirstTypeParameter().hasJavascriptConstructor(NullType.name);
+        let fakeCovarianceToNull = type.getFirstTypeParameter().hasExactClass(NullType.ClassName);
         return invariantTypeParameters || fakeCovarianceToNull;
     }
 }
 
 // TODO: Move to a new file, "genericList.ts"
 export class ListType extends Type {
+    static ClassName = "ListType";
+
     constructor(typeParameter: Type) {
         super("List", [typeParameter]);
     }
+
+    getClassName(): string {
+        return ListType.ClassName;
+    }
 }
 
 // TODO: Move to a new file, "genericOption.ts"
 export class OptionValue extends TypedValue {
+    static ClassName = "OptionValue";
     private readonly value: TypedValue | null;
 
     constructor(type: OptionType, value: TypedValue | null = null) {
@@ -38,6 +51,10 @@ export class OptionValue extends TypedValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return OptionValue.ClassName;
+    }
+
     /**
      * Creates an OptionValue, as a missing option argument.
      */
@@ -80,6 +97,7 @@ export class OptionValue extends TypedValue {
 // TODO: Rename to ListValue, for consistency (though the term is slighly unfortunate).
 // Question for review: or not?
 export class List extends TypedValue {
+    static ClassName = "List";
     private readonly backingCollection: CollectionOfTypedValues;
 
     /**
@@ -95,6 +113,10 @@ export class List extends TypedValue {
         this.backingCollection = new CollectionOfTypedValues(items);
     }
 
+    getClassName(): string {
+        return List.ClassName;
+    }
+
     static fromItems(items: TypedValue[]): List {
         if (items.length == 0) {
             return new List(new TypePlaceholder(), []);
diff --git a/src/smartcontracts/typesystem/genericArray.ts b/src/smartcontracts/typesystem/genericArray.ts
index bc66b0ab3..ff353b84d 100644
--- a/src/smartcontracts/typesystem/genericArray.ts
+++ b/src/smartcontracts/typesystem/genericArray.ts
@@ -4,6 +4,7 @@ import { Type, TypedValue } from "./types";
 
 // A type for known-length arrays. E.g. "array20", "array32", "array64" etc.
 export class ArrayVecType extends Type {
+    static ClassName = "ArrayVecType";
     readonly length: number;
 
     constructor(length: number, typeParameter: Type) {
@@ -12,9 +13,14 @@ export class ArrayVecType extends Type {
         guardTrue(length > 0, "array length > 0");
         this.length = length;
     }
+
+    getClassName(): string {
+        return ArrayVecType.ClassName;
+    }
 }
 
 export class ArrayVec extends TypedValue {
+    static ClassName = "ArrayVec";
     private readonly backingCollection: CollectionOfTypedValues;
 
     constructor(type: ArrayVecType, items: TypedValue[]) {
@@ -23,6 +29,10 @@ export class ArrayVec extends TypedValue {
         this.backingCollection = new CollectionOfTypedValues(items);
     }
 
+    getClassName(): string {
+        return ArrayVec.ClassName;
+    }
+
     getLength(): number {
         return this.backingCollection.getLength();
     }
diff --git a/src/smartcontracts/typesystem/h256.ts b/src/smartcontracts/typesystem/h256.ts
index 8ed8dfc96..b18589513 100644
--- a/src/smartcontracts/typesystem/h256.ts
+++ b/src/smartcontracts/typesystem/h256.ts
@@ -1,13 +1,19 @@
-import * as errors from "../../errors";
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class H256Type extends PrimitiveType {
+    static ClassName = "H256Type";
+
     constructor() {
         super("H256");
     }
+
+    getClassName(): string {
+        return H256Type.ClassName;
+    }
 }
 
 export class H256Value extends PrimitiveValue {
+    static ClassName = "H256Value";
     private readonly value: Buffer;
 
     constructor(value: Buffer) {
@@ -15,6 +21,10 @@ export class H256Value extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return H256Value.ClassName;
+    }
+
     /**
      * Returns whether two objects have the same value.
      */
diff --git a/src/smartcontracts/typesystem/matchers.ts b/src/smartcontracts/typesystem/matchers.ts
index a673cd236..c34e98e82 100644
--- a/src/smartcontracts/typesystem/matchers.ts
+++ b/src/smartcontracts/typesystem/matchers.ts
@@ -29,25 +29,25 @@ export function onTypeSelect<TResult>(
         onOther?: () => TResult;
     }
 ): TResult {
-    if (type.hasJavascriptConstructorInHierarchy(OptionType.name)) {
+    if (type.hasExactClass(OptionType.ClassName)) {
         return selectors.onOption();
     }
-    if (type.hasJavascriptConstructorInHierarchy(ListType.name)) {
+    if (type.hasExactClass(ListType.ClassName)) {
         return selectors.onList();
     }
-    if (type.hasJavascriptConstructorInHierarchy(ArrayVecType.name)) {
+    if (type.hasExactClass(ArrayVecType.ClassName)) {
         return selectors.onArray();
     }
-    if (type.hasJavascriptConstructorInHierarchy(PrimitiveType.name)) {
+    if (type.hasClassOrSuperclass(PrimitiveType.ClassName)) {
         return selectors.onPrimitive();
     }
-    if (type.hasJavascriptConstructorInHierarchy(StructType.name)) {
+    if (type.hasExactClass(StructType.ClassName)) {
         return selectors.onStruct();
     }
-    if (type.hasJavascriptConstructorInHierarchy(TupleType.name)) {
+    if (type.hasExactClass(TupleType.ClassName)) {
         return selectors.onTuple();
     }
-    if (type.hasJavascriptConstructorInHierarchy(EnumType.name)) {
+    if (type.hasExactClass(EnumType.ClassName)) {
         return selectors.onEnum();
     }
 
@@ -71,25 +71,25 @@ export function onTypedValueSelect<TResult>(
         onOther?: () => TResult;
     }
 ): TResult {
-    if (value.hasJavascriptConstructorInHierarchy(PrimitiveValue.name)) {
+    if (value.hasClassOrSuperclass(PrimitiveValue.ClassName)) {
         return selectors.onPrimitive();
     }
-    if (value.hasJavascriptConstructorInHierarchy(OptionValue.name)) {
+    if (value.hasExactClass(OptionValue.ClassName)) {
         return selectors.onOption();
     }
-    if (value.hasJavascriptConstructorInHierarchy(List.name)) {
+    if (value.hasExactClass(List.ClassName)) {
         return selectors.onList();
     }
-    if (value.hasJavascriptConstructorInHierarchy(ArrayVec.name)) {
+    if (value.hasExactClass(ArrayVec.ClassName)) {
         return selectors.onArray();
     }
-    if (value.hasJavascriptConstructorInHierarchy(Struct.name)) {
+    if (value.hasExactClass(Struct.ClassName)) {
         return selectors.onStruct();
     }
-    if (value.hasJavascriptConstructorInHierarchy(Tuple.name)) {
+    if (value.hasExactClass(Tuple.ClassName)) {
         return selectors.onTuple();
     }
-    if (value.hasJavascriptConstructorInHierarchy(EnumValue.name)) {
+    if (value.hasExactClass(EnumValue.ClassName)) {
         return selectors.onEnum();
     }
 
@@ -114,28 +114,28 @@ export function onPrimitiveValueSelect<TResult>(
         onOther?: () => TResult;
     }
 ): TResult {
-    if (value.hasJavascriptConstructorInHierarchy(BooleanValue.name)) {
+    if (value.hasExactClass(BooleanValue.ClassName)) {
         return selectors.onBoolean();
     }
-    if (value.hasJavascriptConstructorInHierarchy(NumericalValue.name)) {
+    if (value.hasClassOrSuperclass(NumericalValue.ClassName)) {
         return selectors.onNumerical();
     }
-    if (value.hasJavascriptConstructorInHierarchy(AddressValue.name)) {
+    if (value.hasExactClass(AddressValue.ClassName)) {
         return selectors.onAddress();
     }
-    if (value.hasJavascriptConstructorInHierarchy(BytesValue.name)) {
+    if (value.hasExactClass(BytesValue.ClassName)) {
         return selectors.onBytes();
     }
-    if (value.hasJavascriptConstructorInHierarchy(StringValue.name)) {
+    if (value.hasExactClass(StringValue.ClassName)) {
         return selectors.onString();
     }
-    if (value.hasJavascriptConstructorInHierarchy(H256Value.name)) {
+    if (value.hasExactClass(H256Value.ClassName)) {
         return selectors.onH256();
     }
-    if (value.hasJavascriptConstructorInHierarchy(TokenIdentifierValue.name)) {
+    if (value.hasExactClass(TokenIdentifierValue.ClassName)) {
         return selectors.onTypeIdentifier();
     }
-    if (value.hasJavascriptConstructorInHierarchy(NothingValue.name)) {
+    if (value.hasExactClass(NothingValue.ClassName)) {
         return selectors.onNothing();
     }
     if (selectors.onOther) {
@@ -159,28 +159,28 @@ export function onPrimitiveTypeSelect<TResult>(
         onOther?: () => TResult;
     }
 ): TResult {
-    if (type.hasJavascriptConstructorInHierarchy(BooleanType.name)) {
+    if (type.hasExactClass(BooleanType.ClassName)) {
         return selectors.onBoolean();
     }
-    if (type.hasJavascriptConstructorInHierarchy(NumericalType.name)) {
+    if (type.hasClassOrSuperclass(NumericalType.ClassName)) {
         return selectors.onNumerical();
     }
-    if (type.hasJavascriptConstructorInHierarchy(AddressType.name)) {
+    if (type.hasExactClass(AddressType.ClassName)) {
         return selectors.onAddress();
     }
-    if (type.hasJavascriptConstructorInHierarchy(BytesType.name)) {
+    if (type.hasExactClass(BytesType.ClassName)) {
         return selectors.onBytes();
     }
-    if (type.hasJavascriptConstructorInHierarchy(StringType.name)) {
+    if (type.hasExactClass(StringType.ClassName)) {
         return selectors.onString();
     }
-    if (type.hasJavascriptConstructorInHierarchy(H256Type.name)) {
+    if (type.hasExactClass(H256Type.ClassName)) {
         return selectors.onH256();
     }
-    if (type.hasJavascriptConstructorInHierarchy(TokenIdentifierType.name)) {
+    if (type.hasExactClass(TokenIdentifierType.ClassName)) {
         return selectors.onTokenIndetifier();
     }
-    if (type.hasJavascriptConstructorInHierarchy(NothingType.name)) {
+    if (type.hasExactClass(NothingType.ClassName)) {
         return selectors.onNothing();
     }
     if (selectors.onOther) {
diff --git a/src/smartcontracts/typesystem/nothing.ts b/src/smartcontracts/typesystem/nothing.ts
index 1bba52d85..bcca6ecba 100644
--- a/src/smartcontracts/typesystem/nothing.ts
+++ b/src/smartcontracts/typesystem/nothing.ts
@@ -1,16 +1,28 @@
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class NothingType extends PrimitiveType {
+    static ClassName = "NothingType";
+
     constructor() {
         super("nothing");
     }
+
+    getClassName(): string {
+        return NothingType.ClassName;
+    }
 }
 
 export class NothingValue extends PrimitiveValue {
+    static ClassName = "NothingValue";
+
     constructor() {
         super(new NothingType());
     }
 
+    getClassName(): string {
+        return NothingValue.ClassName;
+    }
+
     equals(_other: NothingValue): boolean {
         return false;
     }
diff --git a/src/smartcontracts/typesystem/numerical.ts b/src/smartcontracts/typesystem/numerical.ts
index 831d44016..b77ece44d 100644
--- a/src/smartcontracts/typesystem/numerical.ts
+++ b/src/smartcontracts/typesystem/numerical.ts
@@ -3,6 +3,8 @@ import { PrimitiveType, PrimitiveValue, Type } from "./types";
 import BigNumber from "bignumber.js";
 
 export class NumericalType extends PrimitiveType {
+    static ClassName = "NumericalType";
+
     readonly sizeInBytes: number;
     readonly withSign: boolean;
 
@@ -12,6 +14,10 @@ export class NumericalType extends PrimitiveType {
         this.withSign = withSign;
     }
 
+    getClassName(): string {
+        return NumericalType.ClassName;
+    }
+
     hasFixedSize(): boolean {
         return this.sizeInBytes ? true : false;
     }
@@ -22,69 +28,130 @@ export class NumericalType extends PrimitiveType {
 }
 
 export class U8Type extends NumericalType {
+    static ClassName = "U8Type";
+
     constructor() {
         super("u8", 1, false);
     }
+
+    getClassName(): string {
+        return U8Type.ClassName;
+    }
 }
 
 export class I8Type extends NumericalType {
+    static ClassName = "I8Type";
+
     constructor() {
         super("i8", 1, true);
     }
+
+    getClassName(): string {
+        return I8Type.ClassName;
+    }
 }
 
 export class U16Type extends NumericalType {
+    static ClassName = "U16Type";
+
     constructor() {
         super("u16", 2, false);
     }
+
+    getClassName(): string {
+        return U16Type.ClassName;
+    }
 }
 
 export class I16Type extends NumericalType {
+    static ClassName = "I16Type";
+
     constructor() {
         super("i16", 2, true);
     }
+
+    getClassName(): string {
+        return I16Type.ClassName;
+    }
 }
 
 export class U32Type extends NumericalType {
+    static ClassName = "U32Type";
+
     constructor() {
         super("u32", 4, false);
     }
+
+    getClassName(): string {
+        return U32Type.ClassName;
+    }
 }
 
 export class I32Type extends NumericalType {
+    static ClassName = "I32Type";
+
     constructor() {
         super("i32", 4, true);
     }
+
+    getClassName(): string {
+        return I32Type.ClassName;
+    }
 }
 
 export class U64Type extends NumericalType {
+    static ClassName = "U64Type";
+
     constructor() {
         super("u64", 8, false);
     }
+
+    getClassName(): string {
+        return U64Type.ClassName;
+    }
 }
 
 export class I64Type extends NumericalType {
+    static ClassName = "I64Type";
+
     constructor() {
         super("i64", 8, true);
     }
+
+    getClassName(): string {
+        return I64Type.ClassName;
+    }
 }
 
 export class BigUIntType extends NumericalType {
+    static ClassName = "BigUIntType";
+
     constructor() {
         super("BigUint", 0, false);
     }
+
+    getClassName(): string {
+        return BigUIntType.ClassName;
+    }
 }
 
 export class BigIntType extends NumericalType {
+    static ClassName = "BigIntType";
+
     constructor() {
         super("Bigint", 0, true);
     }
+
+    getClassName(): string {
+        return BigIntType.ClassName;
+    }
 }
 
 /**
  * A numerical value fed to or fetched from a Smart Contract contract, as a strongly-typed, immutable abstraction.
  */
 export class NumericalValue extends PrimitiveValue {
+    static ClassName = "NumericalValue";
     readonly value: BigNumber;
     readonly sizeInBytes: number | undefined;
     readonly withSign: boolean;
@@ -105,6 +172,10 @@ export class NumericalValue extends PrimitiveValue {
         }
     }
 
+    getClassName(): string {
+        return NumericalValue.ClassName;
+    }
+
     /**
      * Returns whether two objects have the same value.
      * 
@@ -124,61 +195,121 @@ export class NumericalValue extends PrimitiveValue {
 }
 
 export class U8Value extends NumericalValue {
+    static ClassName = "U8Value";
+
     constructor(value: BigNumber.Value) {
         super(new U8Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return U8Value.ClassName;
+    }
 }
 
 export class I8Value extends NumericalValue {
+    static ClassName = "I8Value";
+
     constructor(value: BigNumber.Value) {
         super(new I8Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return I8Value.ClassName;
+    }
 }
 
 export class U16Value extends NumericalValue {
+    static ClassName = "U16Value";
+
     constructor(value: BigNumber.Value) {
         super(new U16Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return U16Value.ClassName;
+    }
 }
 
 export class I16Value extends NumericalValue {
+    static ClassName = "I16Value";
+
     constructor(value: BigNumber.Value) {
         super(new I16Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return I16Value.ClassName;
+    }
 }
 
 export class U32Value extends NumericalValue {
+    static ClassName = "U32Value";
+
     constructor(value: BigNumber.Value) {
         super(new U32Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return U32Value.ClassName;
+    }
 }
 
 export class I32Value extends NumericalValue {
+    static ClassName = "I32Value";
+
     constructor(value: BigNumber.Value) {
         super(new I32Type(), new BigNumber(value));
     }
+
+    getClassName(): string {
+        return I32Value.ClassName;
+    }
 }
 
 export class U64Value extends NumericalValue {
+    static ClassName = "U64Value";
+
     constructor(value: BigNumber.Value) {
         super(new U64Type(), value);
     }
+
+    getClassName(): string {
+        return U64Value.ClassName;
+    }
 }
 
 export class I64Value extends NumericalValue {
+    static ClassName = "I64Value";
+
     constructor(value: BigNumber.Value) {
         super(new I64Type(), value);
     }
+
+    getClassName(): string {
+        return I64Value.ClassName;
+    }
 }
 
 export class BigUIntValue extends NumericalValue {
+    static ClassName = "BigUIntValue";
+
     constructor(value: BigNumber.Value) {
         super(new BigUIntType(), value);
     }
+
+    getClassName(): string {
+        return BigUIntValue.ClassName;
+    }
 }
 
 export class BigIntValue extends NumericalValue {
+    static ClassName = "BigIntValue";
+
     constructor(value: BigNumber.Value) {
         super(new BigIntType(), value);
     }
+
+    getClassName(): string {
+        return BigIntValue.ClassName;
+    }
 }
diff --git a/src/smartcontracts/typesystem/string.ts b/src/smartcontracts/typesystem/string.ts
index dec860bbb..901c897bf 100644
--- a/src/smartcontracts/typesystem/string.ts
+++ b/src/smartcontracts/typesystem/string.ts
@@ -1,12 +1,19 @@
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class StringType extends PrimitiveType {
+    static ClassName = "StringType";
+
     constructor() {
         super("utf-8 string");
     }
+
+    getClassName(): string {
+        return StringType.ClassName;
+    }
 }
 
 export class StringValue extends PrimitiveValue {
+    static ClassName = "StringValue";
     private readonly value: string;
 
     constructor(value: string) {
@@ -14,6 +21,10 @@ export class StringValue extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return StringValue.ClassName;
+    }
+
     /**
      * Creates a StringValue from a utf-8 string.
      */
diff --git a/src/smartcontracts/typesystem/struct.ts b/src/smartcontracts/typesystem/struct.ts
index b1eec34bd..965a2b065 100644
--- a/src/smartcontracts/typesystem/struct.ts
+++ b/src/smartcontracts/typesystem/struct.ts
@@ -2,6 +2,7 @@ import { FieldDefinition, Field, Fields } from "./fields";
 import { CustomType, TypedValue } from "./types";
 
 export class StructType extends CustomType {
+    static ClassName = "StructType";
     private readonly fieldsDefinitions: FieldDefinition[] = [];
 
     constructor(name: string, fieldsDefinitions: FieldDefinition[]) {
@@ -9,6 +10,10 @@ export class StructType extends CustomType {
         this.fieldsDefinitions = fieldsDefinitions;
     }
 
+    getClassName(): string {
+        return StructType.ClassName;
+    }
+
     static fromJSON(json: { name: string, fields: any[] }): StructType {
         let definitions = (json.fields || []).map(definition => FieldDefinition.fromJSON(definition));
         return new StructType(json.name, definitions);
@@ -22,6 +27,7 @@ export class StructType extends CustomType {
 // TODO: implement setField(), convenience method.
 // TODO: Hold fields in a map (by name), and use the order within "field definitions" to perform codec operations.
 export class Struct extends TypedValue {
+    static ClassName = "Struct";
     private readonly fields: Field[] = [];
 
     /**
@@ -34,6 +40,10 @@ export class Struct extends TypedValue {
         this.checkTyping();
     }
 
+    getClassName(): string {
+        return Struct.ClassName;
+    }
+
     private checkTyping() {
         let type = <StructType>this.getType();
         let definitions = type.getFieldsDefinitions();
diff --git a/src/smartcontracts/typesystem/tokenIdentifier.ts b/src/smartcontracts/typesystem/tokenIdentifier.ts
index 757056f96..475b79653 100644
--- a/src/smartcontracts/typesystem/tokenIdentifier.ts
+++ b/src/smartcontracts/typesystem/tokenIdentifier.ts
@@ -1,13 +1,19 @@
-import * as errors from "../../errors";
 import { PrimitiveType, PrimitiveValue } from "./types";
 
 export class TokenIdentifierType extends PrimitiveType {
+    static ClassName = "TokenIdentifierType";
+
     constructor() {
         super("TokenIdentifier");
     }
+
+    getClassName(): string {
+        return TokenIdentifierType.ClassName;
+    }
 }
 
 export class TokenIdentifierValue extends PrimitiveValue {
+    static ClassName = "TokenIdentifierValue";
     private readonly value: Buffer;
 
     constructor(value: Buffer) {
@@ -15,6 +21,10 @@ export class TokenIdentifierValue extends PrimitiveValue {
         this.value = value;
     }
 
+    getClassName(): string {
+        return TokenIdentifierValue.ClassName;
+    }
+
     getLength(): number {
         return this.value.length;
     }
diff --git a/src/smartcontracts/typesystem/tuple.ts b/src/smartcontracts/typesystem/tuple.ts
index d01cbcae6..d22125ce2 100644
--- a/src/smartcontracts/typesystem/tuple.ts
+++ b/src/smartcontracts/typesystem/tuple.ts
@@ -5,10 +5,16 @@ import { Type, TypedValue } from "./types";
 import { StructType } from "./struct";
 
 export class TupleType extends StructType {
+    static ClassName = "TupleType";
+    
     constructor(...typeParameters: Type[]) {
         super(TupleType.prepareName(typeParameters), TupleType.prepareFieldDefinitions(typeParameters));
     }
 
+    getClassName(): string {
+        return TupleType.ClassName;
+    }
+
     private static prepareName(typeParameters: Type[]): string {
         let fields: string = typeParameters.map(type => type.toString()).join(", ");
         let result = `tuple${fields.length}<${fields}>`;
@@ -29,10 +35,16 @@ function prepareFieldName(fieldIndex: number) {
 // Or let Tuple be the base class, but have Struct as a specialization of it, "named tuple"?
 // Or leave as it is?
 export class Tuple extends Struct {
+    static ClassName = "Tuple";
+
     constructor(type: TupleType, fields: Field[]) {
         super(type, fields);
     }
 
+    getClassName(): string {
+        return Tuple.ClassName;
+    }
+
     static fromItems(items: TypedValue[]): Tuple {
         if (items.length < 1) {
             // TODO: Define a better error.
diff --git a/src/smartcontracts/typesystem/typeMapper.ts b/src/smartcontracts/typesystem/typeMapper.ts
index 49d3f407a..d9cf4f9af 100644
--- a/src/smartcontracts/typesystem/typeMapper.ts
+++ b/src/smartcontracts/typesystem/typeMapper.ts
@@ -100,12 +100,12 @@ export class TypeMapper {
     mapRecursiveType(type: Type): Type | null {
         let isGeneric = type.isGenericType();
 
-        if (type.hasJavascriptConstructor(EnumType.name)) {
+        if (type.hasExactClass(EnumType.ClassName)) {
             // This will call mapType() recursively, for all the enum variant fields.
             return this.mapEnumType(<EnumType>type);
         }
 
-        if (type.hasJavascriptConstructor(StructType.name)) {
+        if (type.hasExactClass(StructType.ClassName)) {
             // This will call mapType() recursively, for all the struct's fields.
             return this.mapStructType(<StructType>type);
         }
diff --git a/src/smartcontracts/typesystem/types.spec.ts b/src/smartcontracts/typesystem/types.spec.ts
index 4daa8b935..bd96e803c 100644
--- a/src/smartcontracts/typesystem/types.spec.ts
+++ b/src/smartcontracts/typesystem/types.spec.ts
@@ -7,7 +7,7 @@ import { AddressType } from "./address";
 import { OptionType } from "./generic";
 import { TypeExpressionParser } from "./typeExpressionParser";
 import BigNumber from "bignumber.js";
-import { BytesType} from "./bytes";
+import { BytesType, BytesValue} from "./bytes";
 import { StringType } from "./string";
 
 describe("test types", () => {
@@ -18,7 +18,7 @@ describe("test types", () => {
         assert.throw(() => new NumericalValue(new U16Type(), <any>{ foobar: 42 }), errors.ErrInvalidArgument);
     });
 
-    it("should report type hierarchy", () => {
+    it("should be assignable from", () => {
         assert.isTrue((new Type("Type")).isAssignableFrom(new PrimitiveType("PrimitiveType")));
         assert.isTrue((new Type("Type")).isAssignableFrom(new BooleanType()));
         assert.isTrue((new Type("Type")).isAssignableFrom(new AddressType()));
@@ -58,4 +58,12 @@ describe("test types", () => {
         assert.equal(parser.parse("utf-8 string").getFullyQualifiedName(), "erdjs:types:utf-8 string");
         assert.equal(parser.parse("Option<u32>").getFullyQualifiedName(), "erdjs:types:Option<erdjs:types:u32>");
     });
+
+    it("types and values should have correct JavaScript class hierarchy", () => {
+        assert.deepEqual(new U32Type().getClassHierarchy(), ["Type", "PrimitiveType", "NumericalType", "U32Type"]);
+        assert.deepEqual(new U32Value(42).getClassHierarchy(), ["TypedValue", "PrimitiveValue", "NumericalValue", "U32Value"]);
+
+        assert.deepEqual(new BytesType().getClassHierarchy(), ["Type", "PrimitiveType", "BytesType"]);
+        assert.deepEqual(new BytesValue(Buffer.from("foobar")).getClassHierarchy(), ["TypedValue", "PrimitiveValue", "BytesValue"]);
+    });
 });
diff --git a/src/smartcontracts/typesystem/types.ts b/src/smartcontracts/typesystem/types.ts
index b8ae56728..c1f060116 100644
--- a/src/smartcontracts/typesystem/types.ts
+++ b/src/smartcontracts/typesystem/types.ts
@@ -1,4 +1,4 @@
-import { getJavascriptConstructorsNamesInHierarchy, getJavascriptPrototypesInHierarchy, hasJavascriptConstructor } from "../../reflection";
+import { getJavascriptPrototypesInHierarchy } from "../../reflection";
 import { guardTrue, guardValueIsSet } from "../../utils";
 
 /**
@@ -6,6 +6,8 @@ import { guardTrue, guardValueIsSet } from "../../utils";
  * Once instantiated as a Type, a generic type is "closed" (as opposed to "open").
  */
 export class Type {
+    static ClassName = "Type";
+
     private readonly name: string;
     private readonly typeParameters: Type[];
     protected readonly cardinality: TypeCardinality;
@@ -22,6 +24,16 @@ export class Type {
         return this.name;
     }
 
+    getClassName() {
+        return Type.ClassName;
+    }
+
+    getClassHierarchy(): string[] {
+        let prototypes = getJavascriptPrototypesInHierarchy(this, prototype => prototype.belongsToTypesystem);
+        let classNames = prototypes.map(prototype => (<Type>prototype).getClassName()).reverse();
+        return classNames;
+    }
+
     /**
      * Gets the fully qualified name of the type, to allow for better (efficient and non-ambiguous) type comparison within erdjs' typesystem.
      */
@@ -33,12 +45,13 @@ export class Type {
             `erdjs:types:${this.getName()}`;
     }
 
-    hasJavascriptConstructor(javascriptConstructorName: string): boolean {
-        return hasJavascriptConstructor(this, javascriptConstructorName);
+    hasExactClass(className: string): boolean {
+        return this.getClassName() == className;
     }
 
-    hasJavascriptConstructorInHierarchy(javascriptConstructorName: string): boolean {
-        return getJavascriptConstructorsNamesInHierarchy(this, prototype => prototype.belongsToTypesystem).includes(javascriptConstructorName);
+    hasClassOrSuperclass(className: string): boolean {
+        let hierarchy = this.getClassHierarchy();
+        return hierarchy.includes(className);
     }
 
     getTypeParameters(): Type[] {
@@ -111,13 +124,7 @@ export class Type {
             return true;
         }
 
-        let javascriptConstructorNameOfThis = this.constructor.name;
-        let javascriptConstructorNamesInHierarchyOfOther = getJavascriptConstructorsNamesInHierarchy(other, prototype => prototype.belongsToTypesystem);
-        if (javascriptConstructorNamesInHierarchyOfOther.includes(javascriptConstructorNameOfThis)) {
-            return true;
-        }
-
-        return false;
+        return other.hasClassOrSuperclass(this.getClassName());
     }
 
     private static getFullyQualifiedNamesInHierarchy(type: Type): string[] {
@@ -143,7 +150,7 @@ export class Type {
     /**
      * A special marker for types within erdjs' typesystem.
      */
-    private belongsToTypesystem() {}
+    belongsToTypesystem() {}
 }
 
 /**
@@ -204,21 +211,43 @@ export class TypeCardinality {
 }
 
 export class PrimitiveType extends Type {
+    static ClassName = "PrimitiveType";
+
     constructor(name: string) {
         super(name);
     }
+
+    getClassName(): string {
+        return PrimitiveType.ClassName;
+    }
 }
 
 export abstract class CustomType extends Type {
+    static ClassName = "CustomType";
+
+    getClassName(): string {
+        return CustomType.ClassName;
+    }
 }
 
 export abstract class TypedValue {
+    static ClassName = "TypedValue";
     private readonly type: Type;
 
     constructor(type: Type) {
         this.type = type;
     }
 
+    getClassName(): string {
+        return TypedValue.ClassName;
+    }
+
+    getClassHierarchy(): string[] {
+        let prototypes = getJavascriptPrototypesInHierarchy(this, prototype => prototype.belongsToTypesystem);
+        let classNames = prototypes.map(prototype => (<TypedValue>prototype).getClassName()).reverse();
+        return classNames;
+    }
+
     getType(): Type {
         return this.type;
     }
@@ -226,24 +255,31 @@ export abstract class TypedValue {
     abstract equals(other: any): boolean;
     abstract valueOf(): any;
 
-    hasJavascriptConstructor(javascriptConstructorName: string): boolean {
-        return hasJavascriptConstructor(this, javascriptConstructorName);
+    hasExactClass(className: string): boolean {
+        return this.getClassName() == className;
     }
 
-    hasJavascriptConstructorInHierarchy(javascriptConstructorName: string): boolean {
-        return getJavascriptConstructorsNamesInHierarchy(this, prototype => prototype.belongsToTypesystem).includes(javascriptConstructorName);
+    hasClassOrSuperclass(className: string): boolean {
+        let hierarchy = this.getClassHierarchy();
+        return hierarchy.includes(className);
     }
 
     /**
      * A special marker for values within erdjs' typesystem.
      */
-     private belongsToTypesystem() {}
+    belongsToTypesystem() {}
 }
 
 export abstract class PrimitiveValue extends TypedValue {
+    static ClassName = "PrimitiveValue";
+
     constructor(type: Type) {
         super(type);
     }
+
+    getClassName(): string {
+        return PrimitiveValue.ClassName;
+    }
 }
 
 export function isTyped(value: any) {
@@ -251,14 +287,26 @@ export function isTyped(value: any) {
 }
 
 export class TypePlaceholder extends Type {
+    static ClassName = "TypePlaceholder";
+
     constructor() {
         super("...");
     }
+
+    getClassName(): string {
+        return TypePlaceholder.ClassName;
+    }
 }
 
 
 export class NullType extends Type {
+    static ClassName = "NullType";
+
     constructor() {
         super("?");
     }
+
+    getClassName(): string {
+        return NullType.ClassName;
+    }
 }
diff --git a/src/smartcontracts/typesystem/variadic.ts b/src/smartcontracts/typesystem/variadic.ts
index 1eddfb4e9..a6c7268cf 100644
--- a/src/smartcontracts/typesystem/variadic.ts
+++ b/src/smartcontracts/typesystem/variadic.ts
@@ -1,9 +1,15 @@
 import { Type, TypeCardinality, TypedValue, TypePlaceholder } from "./types";
 
 export class VariadicType extends Type {
+    static ClassName = "VariadicType";
+
     constructor(typeParameter: Type) {
         super("Variadic", [typeParameter], TypeCardinality.variable());
     }
+
+    getClassName(): string {
+        return VariadicType.ClassName;
+    }
 }
 
 /**
@@ -13,6 +19,7 @@ export class VariadicType extends Type {
  * this TypedValue behaves similar to a List.
  */
 export class VariadicValue extends TypedValue {
+    static ClassName = "VariadicValue";
     private readonly items: TypedValue[];
 
     /**
@@ -28,6 +35,10 @@ export class VariadicValue extends TypedValue {
         this.items = items;
     }
 
+    getClassName(): string {
+        return VariadicValue.ClassName;
+    }
+
     static fromItems(...items: TypedValue[]): VariadicValue {
         if (items.length == 0) {
             return new VariadicValue(new VariadicType(new TypePlaceholder()), []);