diff --git a/test/jwt.test.ts b/test/jwt.test.ts
index e72e27a..a45548c 100644
--- a/test/jwt.test.ts
+++ b/test/jwt.test.ts
@@ -1,117 +1,116 @@
 import {beforeAll, describe, expect, setSystemTime, test} from 'bun:test'
 import {JWTcontext} from '../src/jwt'
 
-
-let c!: JWTcontext;
+let c!: JWTcontext
 
 beforeAll(async () => {
-    c = await JWTcontext.new_random()
+  c = await JWTcontext.new_random()
 })
 
 test('Base case', async () => {
-    let payload = {
-        yeet: "yaat",
-        lol: "yes"
-    }
+  let payload = {
+    yeet: 'yaat',
+    lol: 'yes'
+  }
 
-    const jwt = await c.sign(payload, true, "2 days", "pascal", "server")
-    const verified = await c.verify(jwt, "pascal", "server")
-    expect(verified).toEqual(payload)
+  const jwt = await c.sign(payload, true, '2 days', 'pascal', 'server')
+  const verified = await c.verify(jwt, 'pascal', 'server')
+  expect(verified).toEqual(payload)
 })
 
-describe("Audience verification", () => {
-    const cases : [string|string[]|undefined, string|string[]|undefined, boolean][] = [
-        // undefined at verify means we don't enforce that field
-        [undefined, undefined, true],
-        ["value", undefined, true],
-        [["value", "other"], undefined, true],
+describe('Audience verification', () => {
+  const cases: [string | string[] | undefined, string | string[] | undefined, boolean][] = [
+    // undefined at verify means we don't enforce that field
+    [undefined, undefined, true],
+    ['value', undefined, true],
+    [['value', 'other'], undefined, true],
 
-        [undefined, "value", false],
-        [undefined, ["value", "other"], false],
+    [undefined, 'value', false],
+    [undefined, ['value', 'other'], false],
 
-        ["value", "value", true],
-        ["value", ["value", "other"], true],
-        ["value", "yeet", false],
-        ["value", ["yeet", "other"], false],
+    ['value', 'value', true],
+    ['value', ['value', 'other'], true],
+    ['value', 'yeet', false],
+    ['value', ['yeet', 'other'], false],
 
-        [["value", "other"], "value", true],
-        [["value", "other"], ["value", "yeet"], true],
-        [["value", "other"], ["value", "other"], true],
-        [["yeet", "other"], "value", false],
-        [["value", "other"], ["yeet", "yaat"], false],
-    ]
+    [['value', 'other'], 'value', true],
+    [['value', 'other'], ['value', 'yeet'], true],
+    [['value', 'other'], ['value', 'other'], true],
+    [['yeet', 'other'], 'value', false],
+    [['value', 'other'], ['yeet', 'yaat'], false]
+  ]
 
-    for (const [at_sign, at_verify, result] of cases) {
-        test(`${at_sign} and ${at_verify} ${result ? 'should' : "shouldn't"} work`, async () => {
-            const message = "Yeet"
+  for (const [at_sign, at_verify, result] of cases) {
+    test(`${at_sign} and ${at_verify} ${result ? 'should' : "shouldn't"} work`, async () => {
+      const message = 'Yeet'
 
-            const jwt = await c.sign(message, false, undefined, at_sign)
-            const res = await c.verify<string>(jwt, at_verify)
-            if (result) {
-                expect(res).toBe(message)
-            } else {
-                expect(res).toBeNull()
-            }
-        })
-    }
+      const jwt = await c.sign(message, false, undefined, at_sign)
+      const res = await c.verify<string>(jwt, at_verify)
+      if (result) {
+        expect(res).toBe(message)
+      } else {
+        expect(res).toBeNull()
+      }
+    })
+  }
 })
-describe("Issuer verification", () => {
-    const cases: [string|undefined, string|string[]|undefined, boolean][] = [
-        // undefined at verify means don't enforce the field
-        [undefined, undefined, true],
-        ["value", undefined, true],
+describe('Issuer verification', () => {
+  const cases: [string | undefined, string | string[] | undefined, boolean][] = [
+    // undefined at verify means don't enforce the field
+    [undefined, undefined, true],
+    ['value', undefined, true],
 
-        [undefined, "value", false],
-        [undefined, ["value", "other"], false],
+    [undefined, 'value', false],
+    [undefined, ['value', 'other'], false],
 
-        ["value", "value", true],
-        ["value", ["value", "other"], true],
-        ["value", "yeet", false],
-        ["value", ["yeet", "other"], false],
-    ]
+    ['value', 'value', true],
+    ['value', ['value', 'other'], true],
+    ['value', 'yeet', false],
+    ['value', ['yeet', 'other'], false]
+  ]
 
-    for (const [at_sign, at_verify, result] of cases) {
-        test(`${at_sign} and ${at_verify} ${result ? 'should' : "shouldn't"} work`, async () => {
-            const message = "Yaat"
+  for (const [at_sign, at_verify, result] of cases) {
+    test(`${at_sign} and ${at_verify} ${result ? 'should' : "shouldn't"} work`, async () => {
+      const message = 'Yaat'
 
-            const jwt = await c.sign(message, false, undefined, undefined, at_sign)
-            const res = await c.verify<string>(jwt, undefined, at_verify)
-            if (result) {
-                expect(res).toBe(message)
-            } else {
-                expect(res).toBeNull()
-            }
-        })
-    }
+      const jwt = await c.sign(message, false, undefined, undefined, at_sign)
+      const res = await c.verify<string>(jwt, undefined, at_verify)
+      if (result) {
+        expect(res).toBe(message)
+      } else {
+        expect(res).toBeNull()
+      }
+    })
+  }
 })
-test("Expired JWT is rejected", async () => {
-    const message = "yeet"
+test('Expired JWT is rejected', async () => {
+  const message = 'yeet'
 
-    const jwt = await c.sign(message, false, "5min")
+  const jwt = await c.sign(message, false, '5min')
 
-    const today = new Date()
-    today.setDate(today.getDate() + 1)
-    setSystemTime(today)
+  const today = new Date()
+  today.setDate(today.getDate() + 1)
+  setSystemTime(today)
 
-    const res = await c.verify<string>(jwt)
-    expect(res).toBeNull()
+  const res = await c.verify<string>(jwt)
+  expect(res).toBeNull()
 })
 test("Wrong key won't decrypt", async () => {
-    const c2 = await JWTcontext.new_random()
+  const c2 = await JWTcontext.new_random()
 
-    const message = "yeet"
-    const jwt = await c.sign(message)
-    const res = await c2.verify<string>(jwt)
+  const message = 'yeet'
+  const jwt = await c.sign(message)
+  const res = await c2.verify<string>(jwt)
 
-    expect(res).toBeNull()
+  expect(res).toBeNull()
 })
-test("tampered JWT are rejected", async () => {
-    const message = "yeet"
-    let jwt = await c.sign(message)
+test('tampered JWT are rejected', async () => {
+  const message = 'yeet'
+  let jwt = await c.sign(message)
 
-    if (jwt[0] === "a") jwt = "b" + jwt.substring(1)
-    else jwt = "a" + jwt.substring(1)
+  if (jwt[0] === 'a') jwt = 'b' + jwt.substring(1)
+  else jwt = 'a' + jwt.substring(1)
 
-    const res = await c.verify<string>(jwt)
-    expect(res).toBeNull()
+  const res = await c.verify<string>(jwt)
+  expect(res).toBeNull()
 })
diff --git a/test/signature.test.ts b/test/signature.test.ts
index fcb56c2..4cf707d 100644
--- a/test/signature.test.ts
+++ b/test/signature.test.ts
@@ -1,111 +1,111 @@
-import {test, expect, describe} from 'bun:test'
+import {test, expect} from 'bun:test'
 
 import {signature} from '../index'
-import {derive_keypair, gen_keypair, sign, verify} from "../src/signature";
+import {gen_keypair, sign, verify} from '../src/signature'
 
 test('base case', async () => {
-    const keypair = await gen_keypair()
-    expect(keypair.privateKey.extractable).toBeTrue()
-    expect(keypair.publicKey.extractable).toBeTrue()
-    const data = new TextEncoder().encode("Message 123 !")
+  const keypair = await gen_keypair()
+  expect(keypair.privateKey.extractable).toBeTrue()
+  expect(keypair.publicKey.extractable).toBeTrue()
+  const data = new TextEncoder().encode('Message 123 !')
 
-    const sig = await sign(data, keypair.privateKey)
-    const verification = await verify(data, keypair.publicKey, sig)
+  const sig = await sign(data, keypair.privateKey)
+  const verification = await verify(data, keypair.publicKey, sig)
 
-    expect(verification).toBe(true)
+  expect(verification).toBe(true)
 })
 
 test('extractable or not', async () => {
-    const kp1 = await gen_keypair()
-    const kp2 = await gen_keypair(true)
-    const kp3 = await gen_keypair(false)
+  const kp1 = await gen_keypair()
+  const kp2 = await gen_keypair(true)
+  const kp3 = await gen_keypair(false)
 
-    expect(kp1.privateKey.extractable).toBeTrue()
-    expect(kp2.privateKey.extractable).toBeTrue()
-    expect(kp3.privateKey.extractable).toBeFalse()
+  expect(kp1.privateKey.extractable).toBeTrue()
+  expect(kp2.privateKey.extractable).toBeTrue()
+  expect(kp3.privateKey.extractable).toBeFalse()
 
-    expect(kp1.publicKey.extractable).toBeTrue()
-    expect(kp2.publicKey.extractable).toBeTrue()
-    expect(kp3.publicKey.extractable).toBeTrue()
+  expect(kp1.publicKey.extractable).toBeTrue()
+  expect(kp2.publicKey.extractable).toBeTrue()
+  expect(kp3.publicKey.extractable).toBeTrue()
 })
 
 test('inverted keys', async () => {
-    const keypair = await signature.gen_keypair()
-    const data = new TextEncoder().encode("Message 123 !")
+  const keypair = await signature.gen_keypair()
+  const data = new TextEncoder().encode('Message 123 !')
 
-    expect(async () => await sign(data, keypair.publicKey)).toThrow()
+  expect(async () => await sign(data, keypair.publicKey)).toThrow()
 })
 
 test('tampered message', async () => {
-    const keypair = await signature.gen_keypair()
-    const data1 = new TextEncoder().encode("Message 123 !")
-    const data2 = new TextEncoder().encode("Message 321 !")
-    expect(data1).not.toEqual(data2)
+  const keypair = await signature.gen_keypair()
+  const data1 = new TextEncoder().encode('Message 123 !')
+  const data2 = new TextEncoder().encode('Message 321 !')
+  expect(data1).not.toEqual(data2)
 
-    const sig = await sign(data1, keypair.privateKey)
-    const verification = await verify(data2, keypair.publicKey, sig)
+  const sig = await sign(data1, keypair.privateKey)
+  const verification = await verify(data2, keypair.publicKey, sig)
 
-    expect(verification).toBe(false)
+  expect(verification).toBe(false)
 })
 
 test('different keypair', async () => {
-    const keypair = await signature.gen_keypair()
-    const keypair2 = await signature.gen_keypair()
-    const data = new TextEncoder().encode("Message 123 !")
+  const keypair = await signature.gen_keypair()
+  const keypair2 = await signature.gen_keypair()
+  const data = new TextEncoder().encode('Message 123 !')
 
-    const sig = await sign(data, keypair.privateKey)
-    const verification = await verify(data, keypair2.publicKey, sig)
+  const sig = await sign(data, keypair.privateKey)
+  const verification = await verify(data, keypair2.publicKey, sig)
 
-    expect(verification).toBe(false)
+  expect(verification).toBe(false)
 })
 
 test('tampered signature', async () => {
-    const keypair = await signature.gen_keypair()
-    const data = new TextEncoder().encode("Message 123 !")
+  const keypair = await signature.gen_keypair()
+  const data = new TextEncoder().encode('Message 123 !')
 
-    const sig = await sign(data, keypair.privateKey)
-    sig[0] ^= 1
-    const verification = await verify(data, keypair.publicKey, sig)
+  const sig = await sign(data, keypair.privateKey)
+  sig[0] ^= 1
+  const verification = await verify(data, keypair.publicKey, sig)
 
-    expect(verification).toBe(false)
+  expect(verification).toBe(false)
 })
 
-describe('Derive array', () => {
-    test('Case derive key and use it', async () => {
-        const data = new Uint8Array([1])
-        const kp = await derive_keypair(data)
+/*describe('Derive array', () => {
+  test('Case derive key and use it', async () => {
+    const data = new Uint8Array([1])
+    const kp = await derive_keypair(data)
 
-        const message = new Uint8Array(12)
-        const sig = await sign(message, kp[0])
-        const verif = await verify(message, kp[1], sig)
+    const message = new Uint8Array(12)
+    const sig = await sign(message, kp[0])
+    const verif = await verify(message, kp[1], sig)
 
-        expect(verif).toBeTrue()
-    })
+    expect(verif).toBeTrue()
+  })
 
-    test('Same derive, same key', async () => {
-        const data = new Uint8Array([1,2,3])
+  test('Same derive, same key', async () => {
+    const data = new Uint8Array([1, 2, 3])
 
-        const k1 = await derive_keypair(data)
-        const k2 = await derive_keypair(data)
+    const k1 = await derive_keypair(data)
+    const k2 = await derive_keypair(data)
 
-        const message = new Uint8Array(12)
-        const sig = await sign(message, k1[0])
-        const verif = await verify(message, k2[1], sig)
+    const message = new Uint8Array(12)
+    const sig = await sign(message, k1[0])
+    const verif = await verify(message, k2[1], sig)
 
-        expect(verif).toBeTrue()
-    })
+    expect(verif).toBeTrue()
+  })
 
-    test('Different input, different key', async () => {
-        const d1 = new Uint8Array([1,2,3])
-        const d2 = new Uint8Array([3,2,1])
+  test('Different input, different key', async () => {
+    const d1 = new Uint8Array([1, 2, 3])
+    const d2 = new Uint8Array([3, 2, 1])
 
-        const k1 = await derive_keypair(d1)
-        const k2 = await derive_keypair(d2)
+    const k1 = await derive_keypair(d1)
+    const k2 = await derive_keypair(d2)
 
-        const message = new Uint8Array(12)
-        const sig = await sign(message, k1[0])
-        const verif = await verify(message, k2[1], sig)
+    const message = new Uint8Array(12)
+    const sig = await sign(message, k1[0])
+    const verif = await verify(message, k2[1], sig)
 
-        expect(verif).toBeFalse()
-    })
-})
+    expect(verif).toBeFalse()
+  })
+})*/