diff --git a/packages/types/src/codec/Tuple.ts b/packages/types/src/codec/Tuple.ts
index 87917e4a15..a26d1eccc7 100644
--- a/packages/types/src/codec/Tuple.ts
+++ b/packages/types/src/codec/Tuple.ts
@@ -21,14 +21,14 @@ type TupleTypes = TupleType[] | {
 };
 
 /** @internal */
-function decodeTuple (registry: Registry, _Types: TupleConstructors, value?: AnyTupleValue): [Codec[], number] {
+function decodeTuple (registry: Registry, Classes: TupleConstructors, value?: AnyTupleValue): [Codec[], number] {
   if (isU8a(value) || isHex(value)) {
-    return decodeU8a(registry, u8aToU8a(value), _Types);
+    return decodeU8a(registry, u8aToU8a(value), Classes);
   }
 
-  const Types: Constructor[] = Array.isArray(_Types)
-    ? _Types
-    : Object.values(_Types);
+  const Types: Constructor[] = Array.isArray(Classes)
+    ? Classes
+    : Object.values(Classes);
 
   return [
     Types.map((Type, index): Codec => {
@@ -58,16 +58,18 @@ export class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
   #Types: TupleConstructors;
 
   constructor (registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue) {
-    const Clazzes = Array.isArray(Types)
+    const Classes = Array.isArray(Types)
       ? Types.map((t) => typeToConstructor(registry, t))
       : isFunction(Types) || isString(Types)
         ? [typeToConstructor(registry, Types)]
         : mapToTypeMap(registry, Types);
-    const [values, decodedLength] = decodeTuple(registry, Clazzes, value);
+    const [values, decodedLength] = isU8a(value)
+      ? decodeU8a(registry, value, Classes)
+      : decodeTuple(registry, Classes, value);
 
     super(registry, values, decodedLength);
 
-    this.#Types = Clazzes;
+    this.#Types = Classes;
   }
 
   public static with (Types: TupleTypes | TupleType): Constructor<Tuple> {
diff --git a/packages/types/src/codec/VecFixed.ts b/packages/types/src/codec/VecFixed.ts
index d9a778d8e1..6125161201 100644
--- a/packages/types/src/codec/VecFixed.ts
+++ b/packages/types/src/codec/VecFixed.ts
@@ -4,15 +4,15 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, Constructor, Registry } from '../types';
 
-import { assert, u8aConcat } from '@polkadot/util';
+import { assert, isU8a, u8aConcat } from '@polkadot/util';
 
 import { AbstractArray } from './AbstractArray';
-import { typeToConstructor } from './utils';
+import { decodeU8aVec, typeToConstructor } from './utils';
 import { decodeVec } from './Vec';
 
 /** @internal */
-function decodeVecFixed<T extends Codec> (registry: Registry, Type: Constructor<T>, length: number, value: Uint8Array | HexString | unknown[]): [T[], number] {
-  const [values,, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
+function decodeVecFixed<T extends Codec> (registry: Registry, value: Uint8Array | HexString | unknown[], Type: Constructor<T>, length: number): [T[], number, number] {
+  const [values, decodedLength, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
 
   while (values.length < length) {
     values.push(new Type(registry));
@@ -20,7 +20,7 @@ function decodeVecFixed<T extends Codec> (registry: Registry, Type: Constructor<
 
   assert(values.length === length, () => `Expected a length of exactly ${length} entries`);
 
-  return [values, decodedLengthNoOffset];
+  return [values, decodedLength, decodedLengthNoOffset];
 }
 
 /**
@@ -33,9 +33,11 @@ export class VecFixed<T extends Codec> extends AbstractArray<T> {
 
   constructor (registry: Registry, Type: Constructor<T> | string, length: number, value: Uint8Array | HexString | unknown[] = [] as unknown[]) {
     const Clazz = typeToConstructor<T>(registry, Type);
-    const [values, decodedLength] = decodeVecFixed(registry, Clazz, length, value);
+    const [values,, decodedLengthNoOffset] = isU8a(value)
+      ? decodeU8aVec(registry, value, 0, Clazz, length)
+      : decodeVecFixed(registry, value, Clazz, length);
 
-    super(registry, values, decodedLength);
+    super(registry, values, decodedLengthNoOffset);
 
     this.#Type = Clazz;
   }