diff --git a/index.ts b/index.ts
index a012777..f90658d 100644
--- a/index.ts
+++ b/index.ts
@@ -35,7 +35,7 @@ class OTPManager {
     await this.store.set(
       `${this._config.purpose}:${userId}`,
       otp,
-      this._config.expirationTime,
+      this._config.expirationTime
     );
 
     return otp;
diff --git a/otp_store/map_store.ts b/otp_store/map_store.ts
index c70762d..bfe9b89 100644
--- a/otp_store/map_store.ts
+++ b/otp_store/map_store.ts
@@ -1,40 +1,38 @@
-import OTPStore from "./otp_store";
+import OTPStore from './otp_store';
 
 class MapStore extends OTPStore {
-    private _otpMap: Map<string, [number, Date]>;
+  private _otpMap: Map<string, [number, Date]>;
 
-    constructor() {
-        super()
-        this._otpMap = new Map<string, [number, Date]>();
-    }
+  constructor() {
+    super();
+    this._otpMap = new Map<string, [number, Date]>();
+  }
 
-    async get(key: string): Promise<number> {
-        return (this._otpMap.get(key) ?? [0])[0];
-    }
+  async get(key: string): Promise<number> {
+    return (this._otpMap.get(key) ?? [0])[0];
+  }
 
-    async set(key: string, value: number, ttl?: number): Promise<string | null> {
-        try {
-            this._otpMap.set(key, [value, new Date(Date.now() + (ttl ?? 0))]);
+  async set(key: string, value: number, ttl?: number): Promise<string | null> {
+    try {
+      this._otpMap.set(key, [value, new Date(Date.now() + (ttl ?? 0))]);
 
-            setTimeout(() => {
-                this.del(key);
-            }, (ttl ?? 60) * 1000);
-            return "OK"
-        }
-        catch (e) {
-            return String(e);
-        }
+      setTimeout(() => {
+        this.del(key);
+      }, (ttl ?? 60) * 1000);
+      return 'OK';
+    } catch (e) {
+      return String(e);
     }
+  }
 
-    async del(key: string): Promise<number | null> {
-        try {
-            this._otpMap.delete(key);
-            return 1;
-        }
-        catch (e) {
-            return -1
-        }
+  async del(key: string): Promise<number | null> {
+    try {
+      this._otpMap.delete(key);
+      return 1;
+    } catch (e) {
+      return -1;
     }
+  }
 }
 
-export default MapStore;
\ No newline at end of file
+export default MapStore;
diff --git a/otp_store/memcached_store.ts b/otp_store/memcached_store.ts
index 4d7e80b..cb392b9 100644
--- a/otp_store/memcached_store.ts
+++ b/otp_store/memcached_store.ts
@@ -1,59 +1,53 @@
-import OTPStore from './otp_store'
-import Memcached from 'memcached'
+import OTPStore from './otp_store';
+import Memcached from 'memcached';
 
-type MemcachedClient = Memcached
+type MemcachedClient = Memcached;
 
 class MemcachedStore extends OTPStore {
-    private client: MemcachedClient;
+  private client: MemcachedClient;
 
-    constructor(client: MemcachedClient) {
-        super()
-        this.client = client
-    }
+  constructor(client: MemcachedClient) {
+    super();
+    this.client = client;
+  }
 
-    async get(key: string): Promise<number> {
-        var value = 0;
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.get(key, (err, data) => {
-                    if (err) {
-                        reject()
-                    }
-                    value = data
-                    resolve()
-                })
-            }
-        )
-        return value ?? 0
-    }
+  async get(key: string): Promise<number> {
+    var value = 0;
+    await new Promise<void>((resolve, reject) => {
+      this.client.get(key, (err, data) => {
+        if (err) {
+          reject();
+        }
+        value = data;
+        resolve();
+      });
+    });
+    return value ?? 0;
+  }
 
-    async set(key: string, value: number, ttl = 60): Promise<string | null> {
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.set(key, value, ttl, (err) => {
-                    if (err) {
-                        reject()
-                    }
-                    resolve()
-                })
-            }
-        )
-        return null
-    }
+  async set(key: string, value: number, ttl = 60): Promise<string | null> {
+    await new Promise<void>((resolve, reject) => {
+      this.client.set(key, value, ttl, err => {
+        if (err) {
+          reject();
+        }
+        resolve();
+      });
+    });
+    return null;
+  }
 
-    async del(key: string): Promise<number | null> {
-        await new Promise<void>(
-            (resolve, reject) => {
-                this.client.del(key, (err) => {
-                    if (err) {
-                        reject()
-                    }
-                    resolve()
-                })
-            }
-        )
-        return null
-    }
+  async del(key: string): Promise<number | null> {
+    await new Promise<void>((resolve, reject) => {
+      this.client.del(key, err => {
+        if (err) {
+          reject();
+        }
+        resolve();
+      });
+    });
+    return null;
+  }
 }
 
-export default MemcachedStore
\ No newline at end of file
+export default MemcachedStore;
diff --git a/otp_store/otp_store.ts b/otp_store/otp_store.ts
index 326e221..4f0d9ce 100644
--- a/otp_store/otp_store.ts
+++ b/otp_store/otp_store.ts
@@ -1,7 +1,13 @@
 abstract class OTPStore {
-    abstract get(key: string): Promise<number>;
-    abstract set(key: string, value: number, ttl?: number): Promise<string | null>;
-    abstract del(key: string): Promise<number | null>;
+  abstract get(key: string): Promise<number>;
+
+  abstract set(
+    key: string,
+    value: number,
+    ttl?: number
+  ): Promise<string | null>;
+
+  abstract del(key: string): Promise<number | null>;
 }
 
-export default OTPStore;
\ No newline at end of file
+export default OTPStore;
diff --git a/otp_store/redis_store.ts b/otp_store/redis_store.ts
index 940e473..7b35a73 100644
--- a/otp_store/redis_store.ts
+++ b/otp_store/redis_store.ts
@@ -1,28 +1,33 @@
-import OTPStore from './otp_store'
-import { RedisClientType, RedisFunctions, RedisModules, RedisScripts } from '@redis/client';
+import OTPStore from './otp_store';
+import {
+  RedisClientType,
+  RedisFunctions,
+  RedisModules,
+  RedisScripts,
+} from '@redis/client';
 
-type RedisClient = RedisClientType<RedisFunctions, RedisModules, RedisScripts>
+type RedisClient = RedisClientType<RedisFunctions, RedisModules, RedisScripts>;
 
 class RedisStore extends OTPStore {
-    private client: RedisClient;
+  private client: RedisClient;
 
-    constructor(client: RedisClient) {
-        super()
-        this.client = client
-    }
+  constructor(client: RedisClient) {
+    super();
+    this.client = client;
+  }
 
-    async get(key: string): Promise<number> {
-        const value = await this.client.get(key)
-        return value ? parseInt(value) : 0
-    }
+  async get(key: string): Promise<number> {
+    const value = await this.client.get(key);
+    return value ? parseInt(value) : 0;
+  }
 
-    async set(key: string, value: number, ttl = 60): Promise<string | null> {
-        return await this.client.set(key, value.toString(), { EX: ttl })
-    }
+  async set(key: string, value: number, ttl = 60): Promise<string | null> {
+    return await this.client.set(key, value.toString(), { EX: ttl });
+  }
 
-    async del(key: string): Promise<number | null> {
-        return await this.client.del(key)
-    }
+  async del(key: string): Promise<number | null> {
+    return await this.client.del(key);
+  }
 }
 
-export default RedisStore
\ No newline at end of file
+export default RedisStore;
diff --git a/tests/index.test.ts b/tests/index.test.ts
index 26f0067..cd5aea7 100644
--- a/tests/index.test.ts
+++ b/tests/index.test.ts
@@ -1,80 +1,96 @@
-import { expect, test } from 'vitest'
-import OTPManager from '..'
-import { createClient } from '@redis/client'
-import RedisStore from '../otp_store/redis_store'
-import MemcachedStore from '../otp_store/memcached_store'
-import Memcached from 'memcached'
+import { expect, test } from 'vitest';
+import OTPManager from '..';
+import { createClient } from '@redis/client';
+import RedisStore from '../otp_store/redis_store';
+import MemcachedStore from '../otp_store/memcached_store';
+import Memcached from 'memcached';
 
-test.concurrent('Test OTP Manager with default Map store', { timeout: 15000 }, async () => {
+test.concurrent(
+  'Test OTP Manager with default Map store',
+  { timeout: 15000 },
+  async () => {
     const otpManager = new OTPManager({
-        purpose: "Login",
-        otpLength: 6,
-        expirationTime: 5,
+      purpose: 'Login',
+      otpLength: 6,
+      expirationTime: 5,
     });
 
-    const otp = await otpManager.generate("TestUser");
-    expect(String(otp)).toHaveLength(6)
-    expect(await otpManager.verify("TestUser", otp)).toBe(true);
+    const otp = await otpManager.generate('TestUser');
+    expect(String(otp)).toHaveLength(6);
+    expect(await otpManager.verify('TestUser', otp)).toBe(true);
     await new Promise(resolve => setTimeout(resolve, 10000));
-    expect(await otpManager.verify("TestUser", otp)).toBe(false);
-})
+    expect(await otpManager.verify('TestUser', otp)).toBe(false);
+  }
+);
 
-test.concurrent('Test OTP Manager with Redis store', { timeout: 15000 }, async () => {
+test.concurrent(
+  'Test OTP Manager with Redis store',
+  { timeout: 15000 },
+  async () => {
     const redisClient = createClient({
-        url: 'redis://:1234567890@localhost:6379'
+      url: 'redis://:1234567890@localhost:6379',
     });
 
     redisClient.connect();
     const redisStore = new RedisStore(redisClient);
     const otpManager = new OTPManager({
-        purpose: "Login",
-        otpLength: 6,
-        expirationTime: 5,
-        store: redisStore,
+      purpose: 'Login',
+      otpLength: 6,
+      expirationTime: 5,
+      store: redisStore,
     });
 
-    const otp = await otpManager.generate("TestUser");
-    expect(String(otp)).toHaveLength(6)
-    expect(await otpManager.verify("TestUser", otp)).toBe(true);
+    const otp = await otpManager.generate('TestUser');
+    expect(String(otp)).toHaveLength(6);
+    expect(await otpManager.verify('TestUser', otp)).toBe(true);
     await new Promise(resolve => setTimeout(resolve, 10000));
-    expect(await otpManager.verify("TestUser", otp)).toBe(false);
-})
+    expect(await otpManager.verify('TestUser', otp)).toBe(false);
+  }
+);
 
-test.concurrent('Test OTP Manager with Redis store for Valkey', { timeout: 15000 }, async () => {
+test.concurrent(
+  'Test OTP Manager with Redis store for Valkey',
+  { timeout: 15000 },
+  async () => {
     const valkeyClient = createClient({
-        url: 'redis://:1234567890@localhost:6380',
+      url: 'redis://:1234567890@localhost:6380',
     });
 
     valkeyClient.connect();
     const redisStore = new RedisStore(valkeyClient);
     const otpManager = new OTPManager({
-        purpose: "Login",
-        otpLength: 6,
-        expirationTime: 5,
-        store: redisStore,
+      purpose: 'Login',
+      otpLength: 6,
+      expirationTime: 5,
+      store: redisStore,
     });
 
-    const otp = await otpManager.generate("TestUser");
-    expect(String(otp)).toHaveLength(6)
-    expect(await otpManager.verify("TestUser", otp)).toBe(true);
+    const otp = await otpManager.generate('TestUser');
+    expect(String(otp)).toHaveLength(6);
+    expect(await otpManager.verify('TestUser', otp)).toBe(true);
     await new Promise(resolve => setTimeout(resolve, 10000));
-    expect(await otpManager.verify("TestUser", otp)).toBe(false);
-})
+    expect(await otpManager.verify('TestUser', otp)).toBe(false);
+  }
+);
 
-test.concurrent('Test OTP Manager with Memcached store', { timeout: 15000 }, async () => {
-    var memcached = new Memcached(['127.0.0.1:11211'])
+test.concurrent(
+  'Test OTP Manager with Memcached store',
+  { timeout: 15000 },
+  async () => {
+    var memcached = new Memcached(['127.0.0.1:11211']);
 
     const memcachedStore = new MemcachedStore(memcached);
     const otpManager = new OTPManager({
-        purpose: "Login",
-        otpLength: 6,
-        expirationTime: 5,
-        store: memcachedStore,
+      purpose: 'Login',
+      otpLength: 6,
+      expirationTime: 5,
+      store: memcachedStore,
     });
 
-    const otp = await otpManager.generate("TestUser");
-    expect(String(otp)).toHaveLength(6)
-    expect(await otpManager.verify("TestUser", otp)).toBe(true);
+    const otp = await otpManager.generate('TestUser');
+    expect(String(otp)).toHaveLength(6);
+    expect(await otpManager.verify('TestUser', otp)).toBe(true);
     await new Promise(resolve => setTimeout(resolve, 10000));
-    expect(await otpManager.verify("TestUser", otp)).toBe(false);
-})
\ No newline at end of file
+    expect(await otpManager.verify('TestUser', otp)).toBe(false);
+  }
+);
diff --git a/tests/otp_store/map_store.test.ts b/tests/otp_store/map_store.test.ts
index 491511b..851ae33 100644
--- a/tests/otp_store/map_store.test.ts
+++ b/tests/otp_store/map_store.test.ts
@@ -1,12 +1,16 @@
-import { expect, test } from 'vitest'
-import RedisStore from '../../otp_store/redis_store'
-import MapStore from '../../otp_store/map_store'
+import { expect, test } from 'vitest';
+import RedisStore from '../../otp_store/redis_store';
+import MapStore from '../../otp_store/map_store';
 
 test('Test Map Store', async () => {
-    const mapStore: MapStore = new MapStore();
+  const mapStore: MapStore = new MapStore();
 
-    await mapStore.set('test', 123, 60).then(() => { });
-    await mapStore.get('test').then(value => { expect(value).toBe(123) });
-    await mapStore.del('test').then(() => { });
-    await mapStore.get('test').then(value => { expect(value).toBe(0) });
-})
\ No newline at end of file
+  await mapStore.set('test', 123, 60).then(() => {});
+  await mapStore.get('test').then(value => {
+    expect(value).toBe(123);
+  });
+  await mapStore.del('test').then(() => {});
+  await mapStore.get('test').then(value => {
+    expect(value).toBe(0);
+  });
+});
diff --git a/tests/otp_store/memcached_store.test.ts b/tests/otp_store/memcached_store.test.ts
index 02d446c..29b1a64 100644
--- a/tests/otp_store/memcached_store.test.ts
+++ b/tests/otp_store/memcached_store.test.ts
@@ -1,14 +1,18 @@
-import { expect, test } from 'vitest'
-import MemcachedStore from '../../otp_store/memcached_store'
-import Memcached from 'memcached'
+import { expect, test } from 'vitest';
+import MemcachedStore from '../../otp_store/memcached_store';
+import Memcached from 'memcached';
 
 test('Test Memcached Store', async () => {
-    var memcached = new Memcached(['127.0.0.1:11211'])
+  var memcached = new Memcached(['127.0.0.1:11211']);
 
-    const memcachedStore = new MemcachedStore(memcached);
+  const memcachedStore = new MemcachedStore(memcached);
 
-    await memcachedStore.set('test', 123, 60).then(() => { });
-    await memcachedStore.get('test').then(value => { expect(value).toBe(123) });
-    await memcachedStore.del('test').then(() => { });
-    await memcachedStore.get('test').then(value => { expect(value).toBe(0) });
-})
\ No newline at end of file
+  await memcachedStore.set('test', 123, 60).then(() => {});
+  await memcachedStore.get('test').then(value => {
+    expect(value).toBe(123);
+  });
+  await memcachedStore.del('test').then(() => {});
+  await memcachedStore.get('test').then(value => {
+    expect(value).toBe(0);
+  });
+});
diff --git a/tests/otp_store/redis_store.test.ts b/tests/otp_store/redis_store.test.ts
index ac24cfa..f988157 100644
--- a/tests/otp_store/redis_store.test.ts
+++ b/tests/otp_store/redis_store.test.ts
@@ -1,20 +1,22 @@
-import { expect, test } from 'vitest'
-import RedisStore from '../../otp_store/redis_store'
-import { createClient } from '@redis/client'
+import { expect, test } from 'vitest';
+import RedisStore from '../../otp_store/redis_store';
+import { createClient } from '@redis/client';
 
 test('Test Redis Store', async () => {
-    const redisClient = createClient({
-        url: 'redis://:1234567890@localhost:6379'
-    });
+  const redisClient = createClient({
+    url: 'redis://:1234567890@localhost:6379',
+  });
 
-    redisClient.connect();
-    const redisStore = new RedisStore(redisClient);
+  redisClient.connect();
+  const redisStore = new RedisStore(redisClient);
 
-    await redisStore.set('test', 123, 60).then(() => { });
-    await redisStore.get('test').then(value => {
-        console.log(value)
-        expect(value).toBe(123)
-    });
-    await redisStore.del('test').then(() => { });
-    await redisStore.get('test').then(value => { expect(value).toBe(0) });
-})
\ No newline at end of file
+  await redisStore.set('test', 123, 60).then(() => {});
+  await redisStore.get('test').then(value => {
+    console.log(value);
+    expect(value).toBe(123);
+  });
+  await redisStore.del('test').then(() => {});
+  await redisStore.get('test').then(value => {
+    expect(value).toBe(0);
+  });
+});