diff --git a/src/index.ts b/src/index.ts
index 6a07e404..80e33d21 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -118,7 +118,7 @@ export class ERC725 {
   }
 
   /**
-   * To prevent weird behovior from the lib, we must make sure all the schemas are correct before loading them.
+   * To prevent weird behavior from the lib, we must make sure all the schemas are correct before loading them.
    *
    * @param schemas
    * @returns
diff --git a/src/lib/encoder.ts b/src/lib/encoder.ts
index bde305fc..19a90123 100644
--- a/src/lib/encoder.ts
+++ b/src/lib/encoder.ts
@@ -324,30 +324,6 @@ const returnTypesOfUintNCompactBytesArray = () => {
   return types;
 };
 
-/**
- * Encodes any set of strings to string[CompactBytesArray]
- *
- * @param values An array of non restricted strings
- * @returns string[CompactBytesArray]
- */
-const encodeStringCompactBytesArray = (values: string[]): string => {
-  const hexValues: string[] = values.map((element) => utf8ToHex(element));
-
-  return encodeCompactBytesArray(hexValues);
-};
-
-/**
- * Decode a string[CompactBytesArray] to an array of strings
- * @param compactBytesArray A string[CompactBytesArray]
- * @returns An array of strings
- */
-const decodeStringCompactBytesArray = (compactBytesArray: string): string[] => {
-  const hexValues: string[] = decodeCompactBytesArray(compactBytesArray);
-  const stringValues: string[] = hexValues.map((element) => hexToUtf8(element));
-
-  return stringValues;
-};
-
 const valueTypeEncodingMap = {
   bool: {
     encode: (value: boolean) => (value ? '0x01' : '0x00'),
@@ -486,8 +462,17 @@ const valueTypeEncodingMap = {
     decode: (value: string) => decodeCompactBytesArray(value),
   },
   'string[CompactBytesArray]': {
-    encode: (value: string[]) => encodeStringCompactBytesArray(value),
-    decode: (value: string) => decodeStringCompactBytesArray(value),
+    encode: (values: string[]) => {
+      const hexValues: string[] = values.map((element) => utf8ToHex(element));
+      return encodeCompactBytesArray(hexValues);
+    },
+    decode: (value: string) => {
+      const hexValues: string[] = decodeCompactBytesArray(value);
+      const stringValues: string[] = hexValues.map((element) =>
+        hexToUtf8(element),
+      );
+      return stringValues;
+    },
   },
   ...returnTypesOfBytesNCompactBytesArray(),
   ...returnTypesOfUintNCompactBytesArray(),
diff --git a/src/lib/utils.test.ts b/src/lib/utils.test.ts
index 3365d600..eeabee2d 100644
--- a/src/lib/utils.test.ts
+++ b/src/lib/utils.test.ts
@@ -42,8 +42,9 @@ import { isDynamicKeyName } from './encodeKeyName';
 import { decodeKey } from './decodeData';
 
 describe('utils', () => {
-  describe('encodeKey/decodeKey', () => {
+  describe.only('encodeKey/decodeKey', () => {
     const testCases = [
+      // test encoding an array of address
       {
         schema: {
           name: 'LSP3IssuedAssets[]',
@@ -218,10 +219,25 @@ describe('utils', () => {
 
     testCases.forEach((testCase) => {
       it(`encodes/decodes keyType Array / tuples (valueContent: ${testCase.schema.valueContent}, valueType: ${testCase.schema.valueType}`, () => {
+        console.log(
+          'encodeKey(testCase.schema as ERC725JSONSchema, testCase.decodedValue)',
+        );
+        console.log(
+          encodeKey(testCase.schema as ERC725JSONSchema, testCase.decodedValue),
+        );
+
         assert.deepStrictEqual(
           encodeKey(testCase.schema as ERC725JSONSchema, testCase.decodedValue),
           testCase.encodedValue,
         );
+
+        console.log(
+          'decodeKey(testCase.schema as ERC725JSONSchema, testCase.encodedValue)',
+        );
+        console.log(
+          decodeKey(testCase.schema as ERC725JSONSchema, testCase.encodedValue),
+        );
+
         assert.deepStrictEqual(
           decodeKey(testCase.schema as ERC725JSONSchema, testCase.encodedValue),
           testCase.decodedValue,
@@ -397,6 +413,22 @@ describe('utils', () => {
         assert.strictEqual(encodeArrayKey(key, index), expectedValue);
       });
     });
+
+    it('should encode the array length only if passing a number', async () => {
+      // test encoding only the length
+      const schema: ERC725JSONSchema = {
+        name: 'LSP3IssuedAssets[]',
+        key: '0x3a47ab5bd3a594c3a8995f8fa58d0876c96819ca4516bd76100c92462f2f9dc0',
+        keyType: 'Array',
+        valueContent: 'Address',
+        valueType: 'address',
+      };
+
+      const decodedValue = 3;
+      const encodedValue = '0x00000000000000000000000000000003';
+
+      assert.equal(encodeKey(schema, decodedValue), encodedValue);
+    });
   });
 
   describe('encodeData', () => {
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
index f289fb01..f88b5434 100644
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@@ -248,6 +248,11 @@ export function encodeKey(
 
   switch (lowerCaseKeyType) {
     case 'array': {
+      // if we are encoding only the Array length
+      if (typeof value === 'number') {
+        return encodeValueType('uint128', value);
+      }
+
       if (!Array.isArray(value)) {
         console.error("Can't encode a non array for key of type array");
         return null;