diff --git a/CHANGELOG.md b/CHANGELOG.md
index 069d9211c8..1999e805c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@ Changes:
 - Adjust capability detection (only on full-known historic `AccountInfo`)
 - Additional Xcm types
 - Adjust parachain types
+- Remove error logging on createType (details passed in error)
 - Adjust re-encoding of `BitVec` based on decoded length
 
 
diff --git a/packages/rpc-core/src/util/drr.ts b/packages/rpc-core/src/util/drr.ts
index 551b0e41d7..1fad5fe10f 100644
--- a/packages/rpc-core/src/util/drr.ts
+++ b/packages/rpc-core/src/util/drr.ts
@@ -22,7 +22,7 @@ const CMP = (a: unknown, b: unknown): boolean =>
   stringify({ t: a }) === stringify({ t: b });
 
 const ERR = (error: Error): Observable<never> => {
-  l.error(error);
+  l.error(error.message);
 
   throw error;
 };
diff --git a/packages/types/src/create/createClass.ts b/packages/types/src/create/createClass.ts
index 5cba177105..162a4dcd13 100644
--- a/packages/types/src/create/createClass.ts
+++ b/packages/types/src/create/createClass.ts
@@ -52,7 +52,7 @@ function getSubType (value: TypeDef): keyof InterfaceTypes {
 function getTypeClassMap (value: TypeDef): Record<string, keyof InterfaceTypes> {
   const result: Record<string, keyof InterfaceTypes> = {};
 
-  return getSubDefArray(value).reduce((result, sub): Record<string, keyof InterfaceTypes> => {
+  return getSubDefArray(value).reduce<Record<string, keyof InterfaceTypes>>((result, sub) => {
     result[sub.name as string] = sub.type as keyof InterfaceTypes;
 
     return result;
@@ -61,9 +61,7 @@ function getTypeClassMap (value: TypeDef): Record<string, keyof InterfaceTypes>
 
 // create an array of type string constructors from the input
 function getTypeClassArray (value: TypeDef): (keyof InterfaceTypes)[] {
-  return getSubDefArray(value).map(({ type }): keyof InterfaceTypes =>
-    type as keyof InterfaceTypes
-  );
+  return getSubDefArray(value).map(({ type }) => type as keyof InterfaceTypes);
 }
 
 function createInt ({ displayName, length }: TypeDef, Clazz: typeof Int | typeof UInt): Constructor {
@@ -92,7 +90,7 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
 
     return Enum.with(
       subs.every(({ type }) => type === 'Null')
-        ? subs.reduce((out: Record<string, number>, { index, name }, count): Record<string, number> => {
+        ? subs.reduce<Record<string, number>>((out, { index, name }, count) => {
           out[name as string] = index || count;
 
           return out;
@@ -139,7 +137,7 @@ const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => C
     const result: Record<string, number> = {};
 
     return CodecSet.with(
-      getSubDefArray(value).reduce((result, { index, name }): Record<string, number> => {
+      getSubDefArray(value).reduce<Record<string, number>>((result, { index, name }) => {
         result[name as string] = index as number;
 
         return result;
diff --git a/packages/types/src/create/createType.ts b/packages/types/src/create/createType.ts
index f1fd275bb3..0eb0b8c328 100644
--- a/packages/types/src/create/createType.ts
+++ b/packages/types/src/create/createType.ts
@@ -4,27 +4,24 @@
 import type { Codec, Constructor, InterfaceTypes, Registry } from '../types';
 import type { FromReg } from './types';
 
-import { assert, isHex, isU8a, logger, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { assert, isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
 
 import { createClass } from './createClass';
 
 interface CreateOptions {
   blockHash?: Uint8Array | string | null;
   isPedantic?: boolean;
-  withoutLog?: boolean;
 }
 
-const l = logger('registry');
-
 // With isPedantic, actually check that the encoding matches that supplied. This
 // is much slower, but verifies that we have the correct types defined
 // eslint-disable-next-line @typescript-eslint/ban-types
 function checkInstance<T extends Codec = Codec, K extends string = string> (value: Uint8Array, created: FromReg<T, K>): void {
   const u8a = created.toU8a();
   const rawType = created.toRawType();
-  const isEqual = u8aEq(value, u8a) ||
-    // :code entries and singular bytes don't have length-prefixes (when from storage)
-    (rawType === 'Bytes' && value.length === u8a.length);
+  const isEqual = rawType === 'Bytes'
+    ? value.length === u8a.length
+    : u8aEq(value, u8a);
 
   assert(isEqual, () => `${rawType}:: Decoded input doesn't match input, received ${u8aToHex(value, 512)} (${value.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
 }
@@ -59,8 +56,6 @@ export function createTypeUnsafe<T extends Codec = Codec, K extends string = str
     // it provides false warning which is more hinderance than help
     return initType(registry, createClass<T, K>(registry, type), params, options);
   } catch (error) {
-    !options.withoutLog && l.error(error);
-
     throw new Error(`createType(${type}):: ${(error as Error).message}`);
   }
 }
diff --git a/packages/types/src/create/encodeTypes.ts b/packages/types/src/create/encodeTypes.ts
index 69aff6ae68..58c6e3ee97 100644
--- a/packages/types/src/create/encodeTypes.ts
+++ b/packages/types/src/create/encodeTypes.ts
@@ -46,7 +46,7 @@ function encodeSubTypes (sub: TypeDef[], asEnum?: boolean): string {
 
   assert(names.every((n) => !!n), () => `Subtypes does not have consistent names, ${names.join(', ')}`);
 
-  const inner = sub.reduce((result: Record<string, string>, type): Record<string, string> => ({
+  const inner = sub.reduce< Record<string, string>>((result, type) => ({
     ...result,
     [type.name as string]: encodeTypeDef(type)
   }), {});
diff --git a/packages/types/src/create/sanitize.ts b/packages/types/src/create/sanitize.ts
index 9528ad50c8..8cde02e275 100644
--- a/packages/types/src/create/sanitize.ts
+++ b/packages/types/src/create/sanitize.ts
@@ -209,7 +209,7 @@ export function removeWrap (check: string): Mapper {
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function sanitize (value: String | string, options?: SanitizeOptions): string {
-  return mappings.reduce((result, fn): string =>
+  return mappings.reduce<string>((result, fn) =>
     fn(result, options), value.toString()
   ).trim();
 }