@bsv/sdk 1.3.12 → 1.3.14

package/src/primitives/__tests/Schnorr.test.ts

@@ -1,272 +1,284 @@
-import Schnorr from '../../../dist/cjs/src/primitives/Schnorr.js'
-import BigNumber from '../../../dist/cjs/src/primitives/BigNumber.js'
-import Curve from '../../../dist/cjs/src/primitives/Curve.js'
-import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey.js'
+import Schnorr from '../../primitives/Schnorr'
+import BigNumber from '../../primitives/BigNumber'
+import Curve from '../../primitives/Curve'
+import PrivateKey from '../../primitives/PrivateKey'
+import PublicKey from '../../primitives/PublicKey'
+import Point from '../../primitives/Point'
 
 describe('Schnorr Zero-Knowledge Proof', () => {
-    let schnorr: Schnorr
-    let curve: Curve
+  let schnorr: Schnorr
+  let curve: Curve
 
-    beforeAll(() => {
-        schnorr = new Schnorr()
-        curve = new Curve()
-    })
-
-    it('should verify a valid proof', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  beforeAll(() => {
+    schnorr = new Schnorr()
+    curve = new Curve()
+  })
+
+  it('should verify a valid proof', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
 
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(true)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(true)
+  })
 
-    it('should fail verification if proof is tampered (R modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it('should fail verification if proof is tampered (R modified)', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
 
-        // Tamper with R
-        const tamperedR = proof.R.add(curve.g)
-        const tamperedProof = { ...proof, R: tamperedR }
+    // Tamper with R
+    const tamperedR = proof.R.add(curve.g)
+    const tamperedProof = { ...proof, R: tamperedR }
 
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, tamperedProof)
-        expect(result).toBe(false)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
 
-    it('should fail verification if proof is tampered (z modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it('should fail verification if proof is tampered (z modified)', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
 
-        // Tamper with z
-        const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n)
-        const tamperedProof = { ...proof, z: tamperedZ }
+    // Tamper with z
+    const tamperedZ = proof.z.add(new BigNumber(1)).umod(curve.n)
+    const tamperedProof = { ...proof, z: tamperedZ }
 
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, tamperedProof)
-        expect(result).toBe(false)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
 
-    it('should fail verification if proof is tampered (S\' modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it("should fail verification if proof is tampered (S' modified)", () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
 
-        // Tamper with S'
-        const tamperedSPrime = proof.SPrime.add(curve.g)
-        const tamperedProof = { ...proof, SPrime: tamperedSPrime }
+    // Tamper with S'
+    const tamperedSPrime = proof.SPrime.add(curve.g)
+    const tamperedProof = { ...proof, SPrime: tamperedSPrime }
 
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, tamperedProof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if inputs are tampered (A modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, tamperedProof)
+    expect(result).toBe(false)
+  })
+
+  it('should fail verification if inputs are tampered (A modified)', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
 
-        // Tamper with A
-        const tamperedA = A.add(curve.g)
+    // Tamper with A
+    const tamperedA = A.add(curve.g)
 
-        // Verify proof
-        const result = schnorr.verifyProof(tamperedA, B, S, proof)
-        expect(result).toBe(false)
-    })
+    // Verify proof
+    const result = schnorr.verifyProof(tamperedA, B, S, proof)
+    expect(result).toBe(false)
+  })
 
-    it('should fail verification if inputs are tampered (B modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
+  it('should fail verification if inputs are tampered (B modified)', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
 
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
 
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
 
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Tamper with B
-        const tamperedB = B.add(curve.g)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, tamperedB, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if inputs are tampered (S modified)', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Tamper with S
-        const tamperedS = S.add(curve.g)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, tamperedS, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if using wrong private key', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const wrongA = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof using wrong private key
-        const proof = schnorr.generateProof(wrongA, A, B, S)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if using wrong public key', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-        const wrongB = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-        const wrongBPublic = wrongB.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Verify proof with wrong B
-        const result = schnorr.verifyProof(A, wrongBPublic, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should fail verification if shared secret S is incorrect', () => {
-        // Generate private keys
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Intentionally compute incorrect shared secret
-        const S = B.mul(a).add(curve.g)
-
-        // Generate proof with correct S
-        const proof = schnorr.generateProof(a, A, B, B.mul(a))
-
-        // Verify proof with incorrect S
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(false)
-    })
-
-    it('should verify a valid proof with fixed keys', () => {
-        // Use fixed private keys for determinism
-        const a = new PrivateKey(new BigNumber('123456789abcdef123456789abcdef123456789abcdef123456789abcdef', 16))
-        const b = new PrivateKey(new BigNumber('abcdef123456789abcdef123456789abcdef123456789abcdef123456789', 16))
-
-        // Compute public keys
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-
-        // Compute shared secret S = B * a
-        const S = B.mul(a)
-
-        // Generate proof
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        // Verify proof
-        const result = schnorr.verifyProof(A, B, S, proof)
-        expect(result).toBe(true)
-    })
-
-    it('should throw an error if inputs are invalid', () => {
-        const a = PrivateKey.fromRandom()
-        const b = PrivateKey.fromRandom()
-        const A = a.toPublicKey()
-        const B = b.toPublicKey()
-        const S = B.mul(a)
-        const proof = schnorr.generateProof(a, A, B, S)
-
-        expect(() => schnorr.verifyProof(null as any, B, S, proof)).toThrow()
-        expect(() => schnorr.verifyProof(A, null as any, S, proof)).toThrow()
-        expect(() => schnorr.verifyProof(A, B, null as any, proof)).toThrow()
-        expect(() => schnorr.verifyProof(A, B, S, null as any)).toThrow()
-    })
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    // Tamper with B
+    const tamperedB = B.add(curve.g)
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, tamperedB, S, proof)
+    expect(result).toBe(false)
+  })
+
+  it('should fail verification if inputs are tampered (S modified)', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
+
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    // Tamper with S
+    const tamperedS = S.add(curve.g)
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, tamperedS, proof)
+    expect(result).toBe(false)
+  })
+
+  it('should fail verification if using wrong private key', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const wrongA = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
+
+    // Generate proof using wrong private key
+    const proof = schnorr.generateProof(wrongA, A, B, S)
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(false)
+  })
+
+  it('should fail verification if using wrong public key', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+    const wrongB = PrivateKey.fromRandom()
+
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+    const wrongBPublic = wrongB.toPublicKey()
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
+
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    // Verify proof with wrong B
+    const result = schnorr.verifyProof(A, wrongBPublic, S, proof)
+    expect(result).toBe(false)
+  })
+
+  it('should fail verification if shared secret S is incorrect', () => {
+    // Generate private keys
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+
+    // Intentionally compute incorrect shared secret
+    const S = B.mul(a).add(curve.g)
+
+    // Generate proof with correct S
+    const proof = schnorr.generateProof(a, A, B, B.mul(a))
+
+    // Verify proof with incorrect S
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(false)
+  })
+
+  it('should verify a valid proof with fixed keys', () => {
+    // Use fixed private keys for determinism
+    const a = new PrivateKey(
+      new BigNumber(
+        '123456789abcdef123456789abcdef123456789abcdef123456789abcdef',
+        16
+      )
+    )
+    const b = new PrivateKey(
+      new BigNumber(
+        'abcdef123456789abcdef123456789abcdef123456789abcdef123456789',
+        16
+      )
+    )
+
+    // Compute public keys
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+
+    // Compute shared secret S = B * a
+    const S = B.mul(a)
+
+    // Generate proof
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    // Verify proof
+    const result = schnorr.verifyProof(A, B, S, proof)
+    expect(result).toBe(true)
+  })
+
+  it('should throw an error if inputs are invalid', () => {
+    const a = PrivateKey.fromRandom()
+    const b = PrivateKey.fromRandom()
+    const A = a.toPublicKey()
+    const B = b.toPublicKey()
+    const S = B.mul(a)
+    const proof = schnorr.generateProof(a, A, B, S)
+
+    expect(() => schnorr.verifyProof(null as unknown as PublicKey, B, S, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, null as unknown as PublicKey, S, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, B, null as unknown as PublicKey, proof)).toThrow()
+    expect(() => schnorr.verifyProof(A, B, S, null as unknown as { R: Point, SPrime: Point, z: BigNumber })).toThrow() // ✅ Correct cast
+  })
 })

package/src/primitives/__tests/SymmetricKey.test.ts

@@ -1,14 +1,24 @@
-import SymmetricKey from '../../../dist/cjs/src/primitives/SymmetricKey'
+import SymmetricKey from '../../primitives/SymmetricKey'
 import vectors from './SymmetricKey.vectors'
 
 const KEYS: SymmetricKey[] = [
-  new SymmetricKey('5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458', 16),
-  new SymmetricKey('bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4', 16),
-  new SymmetricKey('53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10', 16)
+  new SymmetricKey(
+    '5a90d59d829197983a54d887fdea2dc4c38098f00ba3110f2645633b6ea11458',
+    16
+  ),
+  new SymmetricKey(
+    'bac6ac492f54d7c997fadc1be593a4ace26ecdf37d30b3ad12f34077fb2629e4',
+    16
+  ),
+  new SymmetricKey(
+    '53dcdc6ea6a6910af35a48708f49228e0e6661ea885435080cbabc58e6a14f10',
+    16
+  )
 ]
 
 const PLAINTEXT_1 = 'hello there'
-const CIPHERTEXT_1 = '8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52'
+const CIPHERTEXT_1 =
+  '8c8d25348dfd5240be833215a123173c64919779ab8845a700a4520311504c168ade2d4b728cc53a254f0aba857caaf6af97453ac2ff61487d0d52'
 
 describe('SymmetricKey', () => {
   it('Produces output that can be decrypted', () => {
@@ -19,12 +29,8 @@ describe('SymmetricKey', () => {
   })
   it('Encrypts values as an array', () => {
     const originalValue = [42, 99, 33, 0, 1]
-    const encryptedValue = KEYS[2].encrypt(
-      originalValue
-    )
-    const decryptedValue = KEYS[2].decrypt(
-      encryptedValue
-    )
+    const encryptedValue = KEYS[2].encrypt(originalValue)
+    const decryptedValue = KEYS[2].decrypt(encryptedValue)
     expect(originalValue).toEqual(decryptedValue)
   })
   it('Decrypts a correctly-encrypted value', () => {
@@ -33,10 +39,7 @@ describe('SymmetricKey', () => {
   })
   it('Throws a useful error when decryption fails', () => {
     expect(() => {
-      KEYS[2].decrypt(
-        CIPHERTEXT_1,
-        'hex'
-      )
+      KEYS[2].decrypt(CIPHERTEXT_1, 'hex')
     }).toThrow(new Error('Decryption failed!'))
   })
   it('decrypts values encrypted with the encrypt function', () => {

package/src/primitives/__tests/SymmetricKey.vectors.ts

@@ -13,27 +13,35 @@
  */
 export default [
   {
-    ciphertext: '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
+    ciphertext:
+      '1cf74FpvW0koFZk5e1VQcCtF7UdLj9mtN/L9loFlXwhf6w/06THwVirsvDShuT/KlOjO/HFALj8AcGLU1KRs4zNJDaX2wNebuPkH+qp5N/0cp3fZxgFzHJB3jBPDcdFi8O9WXIBLx9jUQ5KFQk0mZCB2k90VniInWuzqqOQAQQlBy2rgBWp4xg==',
     key: 'LIe9CoVXxDDDKt9F4j2lE+GP4oPcMElwyX+LVsuRLqw=',
-    plaintext: '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
+    plaintext:
+      '5+w9tts+i14GDfPSEJwcaAfce7zVLC7wsRAMnCBqIczkqL08I05FZTl7n14H9hnPkS7HBm3EGWNDKCZ64ckCGg=='
   },
   {
-    ciphertext: 'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
+    ciphertext:
+      'IFh45HxwvK7wgIZr5UDxvUiEkvjsXVV6VIksaEQoTNCPleaRxE1CE1eZj5ZSPa/Mo2HXa2kvEmVAMslY12gMb7qHAHT2fSORB8TJKubKcjwGUrRxqOWvk24lv7QKhq3uhKkJxZSkPBZS6UM+xX+x7Mb53CoC8Z+7Ork50wGRAA415C+T8FIluA==',
     key: 'Di30+CTH8yKVJfXmbkRU6DOesD042IkjZCbFL1lnNqY=',
-    plaintext: '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
+    plaintext:
+      '6pHqDrkIuGmWIpB1spu30PP848D04WlERSjrEZ/JD0jfdS814cOjs4MFkePT1IHeM4+qGFwAMk7HKgWShOKFDQ=='
   },
   {
-    ciphertext: 'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
+    ciphertext:
+      'JeUMCTX3hW7uH7Njfqjtjxd/8jB0Uj4eLLbLNBSMqF3XJmtq2oyX/WWS1po8cwn7jrcK0k8mVxHax/DctH6CIDMc0udBxWYLDyftvIYr448otWmn2IKQN4d3Bh2PKdiIQOo36DO2wOy+T2OJSmJ2XvAkenSZIckCdPIQVpeIi7Bt2ZpHmkObkg==',
     key: 'v7kFn4JdB3OVVjy8lk7UTvWe0vY5Qyzn64Q0EVoezlU=',
-    plaintext: 'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
+    plaintext:
+      'bSYHdJn15pcsaI8CNmfjKQ3ZvMg7zBaxuxBqyWBmCLdqj29bK54C26G1mx5e605hDrFpuJoNSDTECrk67ebffA=='
   },
   {
-    ciphertext: 'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
+    ciphertext:
+      'ktpzKolKsvtWrvLl0yMdGvh5ngd1hiaNcC1b5yuzo2DEKO/4S7gePO/CWOmW/dloHhzfbBQH9rKDFKK7xHHgqYRc',
     key: 'qIgnjD0FfGVMiWo107bP0oHsLA402lhC7AYUFIKY1KQ=',
     plaintext: 'A cat and a mouse.'
   },
   {
-    ciphertext: 'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
+    ciphertext:
+      'vremTalPp+NxN/loEtLMB94tEymdFk2TfBoTWNYcf4sQqYSNkx2WPdJ4LxrIsGuIg9KMOt7FOcIpDb6rRVpP',
     key: 'K7E/bf3wp6hrVeW0V1KvFJS5JZMhyxwPHCIW6wKBTb0=',
     plaintext: 'üñîçø∂é'
   }