@bsv/sdk 1.9.24 → 1.9.30

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

@@ -68,503 +68,335 @@ describe('AES', () => {
 
 describe('ghash', () => {
   it('should ghash', () => {
-    expect(toArray('f38cbb1ad69223dcc3457ae5b6b0f885', 'hex')).toEqual(
-      ghash(
-        toArray(
-          '000000000000000000000000000000000388dace60b6a392f328c2b971b2fe780000000000000000000000' +
-            '0000000080',
-          'hex'
-        ),
-        toArray('66e94bd4ef8a2c3b884cfa59ca342b2e', 'hex')
+    const input = new Uint8Array(
+      toArray(
+        '000000000000000000000000000000000388dace60b6a392f328c2b971b2fe780000000000000000000000' +
+          '0000000080',
+        'hex'
       )
     )
+    const h = new Uint8Array(
+      toArray('66e94bd4ef8a2c3b884cfa59ca342b2e', 'hex')
+    )
+    const out = ghash(input, h)
+
+    expect(toArray('f38cbb1ad69223dcc3457ae5b6b0f885', 'hex')).toEqual(
+      Array.from(out)
+    )
   })
 })
 
 describe('AESGCM', () => {
   it('should encrypt: Test Case 1', () => {
-    const output = AESGCM(
-      [],
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(0)
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray('00000000000000000000000000000000', 'hex')
     )
 
-    expect([]).toEqual(output.result)
+    const output = AESGCM(plainText, iv, key)
+
+    expect([]).toEqual(Array.from(output.result))
     expect(toArray('58e2fccefa7e3061367f1d57a4e7455a', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 2', () => {
-    const output = AESGCM(
-      toArray('00000000000000000000000000000000', 'hex'),
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(
+      toArray('00000000000000000000000000000000', 'hex')
+    )
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray('00000000000000000000000000000000', 'hex')
     )
 
+    const output = AESGCM(plainText, iv, key)
+
     expect(toArray('0388dace60b6a392f328c2b971b2fe78', 'hex')).toEqual(
-      output.result
+      Array.from(output.result)
     )
     expect(toArray('ab6e47d42cec13bdf53a67b21257bddf', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 3', () => {
-    const output = AESGCM(
+    const plainText = new Uint8Array(
       toArray(
         'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
           '809532fcf0e2449a6b525b16aedf5aa0de657ba637b391aafd255',
         'hex'
-      ),
-      [],
-      toArray('cafebabefacedbaddecaf888', 'hex'),
-      toArray('feffe9928665731c6d6a8f9467308308', 'hex')
-    )
-
-    expect(
-      toArray(
-        '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8' +
-          'f6a5aac84aa051ba30b396a0aac973d58e091473f5985',
-        'hex'
       )
-    ).toEqual(output.result)
-    expect(toArray('4d5c2af327cd64a62cf35abd2ba6fab4', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 4', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbaddecaf888', 'hex'),
-      toArray('feffe9928665731c6d6a8f9467308308', 'hex')
     )
-    expect(
-      toArray(
-        '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8' +
-          'f6a5aac84aa051ba30b396a0aac973d58e091',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('5bc94fbc3221a5db94fae95ae7121a47', 'hex')).toEqual(
-      output.authenticationTag
+    const iv = new Uint8Array(
+      toArray('cafebabefacedbaddecaf888', 'hex')
     )
-  })
-
-  it('should encrypt: Test Case 5', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbad', 'hex'),
+    const key = new Uint8Array(
       toArray('feffe9928665731c6d6a8f9467308308', 'hex')
     )
 
-    expect(
-      toArray(
-        '61353b4c2806934a777ff51fa22a4755699b2a714fcdc6f83766e5f97b6c742373806900e49f24b22b0' +
-          '97544d4896b424989b5e1ebac0f07c23f4598',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('3612d2e79e3b0785561be14aaca2fccb', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 6', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray(
-        '9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b525416' +
-          'aedbf5a0de6a57a637b39b',
-        'hex'
-      ),
-      toArray('feffe9928665731c6d6a8f9467308308', 'hex')
-    )
+    const output = AESGCM(plainText, iv, key)
 
     expect(
       toArray(
-        '8ce24998625615b603a033aca13fb894be9112a5c3a211a8ba262a3cca7e2ca701e4a9a4fba43c90ccd' +
-          'cb281d48c7c6fd62875d2aca417034c34aee5',
+        '42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8' +
+          'f6a5aac84aa051ba30b396a0aac973d58e091473f5985',
         'hex'
       )
-    ).toEqual(output.result)
-    expect(toArray('619cc5aefffe0bfa462af43c1699d050', 'hex')).toEqual(
-      output.authenticationTag
+    ).toEqual(Array.from(output.result))
+    expect(toArray('4d5c2af327cd64a62cf35abd2ba6fab4', 'hex')).toEqual(
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 7', () => {
-    const output = AESGCM(
-      [],
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(0)
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray('000000000000000000000000000000000000000000000000', 'hex')
     )
 
-    expect([]).toEqual(output.result)
+    const output = AESGCM(plainText, iv, key)
+
+    expect([]).toEqual(Array.from(output.result))
     expect(toArray('cd33b28ac773f74ba00ed1f312572435', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 8', () => {
-    const output = AESGCM(
-      toArray('00000000000000000000000000000000', 'hex'),
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(
+      toArray('00000000000000000000000000000000', 'hex')
+    )
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray('000000000000000000000000000000000000000000000000', 'hex')
     )
 
+    const output = AESGCM(plainText, iv, key)
+
     expect(toArray('98e7247c07f0fe411c267e4384b0f600', 'hex')).toEqual(
-      output.result
+      Array.from(output.result)
     )
     expect(toArray('2ff58d80033927ab8ef4d4587514f0fb', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 9', () => {
-    const output = AESGCM(
+    const plainText = new Uint8Array(
       toArray(
         'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
           '809532fcf0e2449a6b525b16aedf5aa0de657ba637b391aafd255',
         'hex'
-      ),
-      [],
-      toArray('cafebabefacedbaddecaf888', 'hex'),
-      toArray('feffe9928665731c6d6a8f9467308308feffe9928665731c', 'hex')
-    )
-
-    expect(
-      toArray(
-        '3980ca0b3c00e841eb06fac4872a2757859e1ceaa6efd984628593b40ca1e19c7d773d00c144c525ac6' +
-          '19d18c84a3f4718e2448b2fe324d9ccda2710acade256',
-        'hex'
       )
-    ).toEqual(output.result)
-    expect(toArray('9924a7c8587336bfb118024db8674a14', 'hex')).toEqual(
-      output.authenticationTag
     )
-  })
-
-  it('should encrypt: Test Case 10', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbaddecaf888', 'hex'),
-      toArray('feffe9928665731c6d6a8f9467308308feffe9928665731c', 'hex')
+    const iv = new Uint8Array(
+      toArray('cafebabefacedbaddecaf888', 'hex')
     )
-
-    expect(
-      toArray(
-        '3980ca0b3c00e841eb06fac4872a2757859e1ceaa6efd984628593b40ca1e19c7d773d00c144c525ac6' +
-          '19d18c84a3f4718e2448b2fe324d9ccda2710',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('2519498e80f1478f37ba55bd6d27618c', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 11', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbad', 'hex'),
+    const key = new Uint8Array(
       toArray('feffe9928665731c6d6a8f9467308308feffe9928665731c', 'hex')
     )
 
-    expect(
-      toArray(
-        '0f10f599ae14a154ed24b36e25324db8c566632ef2bbb34f8347280fc4507057fddc29df9a471f75c66' +
-          '541d4d4dad1c9e93a19a58e8b473fa0f062f7',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('65dcc57fcf623a24094fcca40d3533f8', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 12', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray(
-        '9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b5254' +
-          '16aedbf5a0de6a57a637b39b',
-        'hex'
-      ),
-      toArray('feffe9928665731c6d6a8f9467308308feffe9928665731c', 'hex')
-    )
+    const output = AESGCM(plainText, iv, key)
 
     expect(
       toArray(
-        'd27e88681ce3243c4830165a8fdcf9ff1de9a1d8e6b447ef6ef7b79828666e4581e79012af34ddd9e2f' +
-          '037589b292db3e67c036745fa22e7e9b7373b',
+        '3980ca0b3c00e841eb06fac4872a2757859e1ceaa6efd984628593b40ca1e19c7d773d00c144c525ac6' +
+          '19d18c84a3f4718e2448b2fe324d9ccda2710acade256',
         'hex'
       )
-    ).toEqual(output.result)
-    expect(toArray('dcf566ff291c25bbb8568fc3d376a6d9', 'hex')).toEqual(
-      output.authenticationTag
+    ).toEqual(Array.from(output.result))
+    expect(toArray('9924a7c8587336bfb118024db8674a14', 'hex')).toEqual(
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 13', () => {
-    const output = AESGCM(
-      [],
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(0)
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray(
         '0000000000000000000000000000000000000000000000000000000000000000',
         'hex'
       )
     )
 
-    expect([]).toEqual(output.result)
+    const output = AESGCM(plainText, iv, key)
+
+    expect([]).toEqual(Array.from(output.result))
     expect(toArray('530f8afbc74536b9a963b4f1c4cb738b', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 14', () => {
-    const output = AESGCM(
-      toArray('00000000000000000000000000000000', 'hex'),
-      [],
-      toArray('000000000000000000000000', 'hex'),
+    const plainText = new Uint8Array(
+      toArray('00000000000000000000000000000000', 'hex')
+    )
+    const iv = new Uint8Array(
+      toArray('000000000000000000000000', 'hex')
+    )
+    const key = new Uint8Array(
       toArray(
         '0000000000000000000000000000000000000000000000000000000000000000',
         'hex'
       )
     )
 
+    const output = AESGCM(plainText, iv, key)
+
     expect(toArray('cea7403d4d606b6e074ec5d3baf39d18', 'hex')).toEqual(
-      output.result
+      Array.from(output.result)
     )
     expect(toArray('d0d1c8a799996bf0265b98b5d48ab919', 'hex')).toEqual(
-      output.authenticationTag
+      Array.from(output.authenticationTag)
     )
   })
 
   it('should encrypt: Test Case 15', () => {
-    const output = AESGCM(
+    const plainText = new Uint8Array(
       toArray(
         'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
           '809532fcf0e2449a6b525b16aedf5aa0de657ba637b391aafd255',
         'hex'
-      ),
-      [],
-      toArray('cafebabefacedbaddecaf888', 'hex'),
-      toArray(
-        'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
-        'hex'
       )
     )
-
-    expect(
-      toArray(
-        '522dc1f099567d07f47f37a32a84427d643a8cdcbfe5c0c97598a2bd2555d1aa8cb08e48590dbb3da7b' +
-          '08b1056828838c5f61e6393ba7a0abcc9f662898015ad',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('b094dac5d93471bdec1a502270e3cc6c', 'hex')).toEqual(
-      output.authenticationTag
+    const iv = new Uint8Array(
+      toArray('cafebabefacedbaddecaf888', 'hex')
     )
-  })
-
-  it('should encrypt: Test Case 16', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbaddecaf888', 'hex'),
+    const key = new Uint8Array(
       toArray(
         'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
         'hex'
       )
     )
 
-    expect(
-      toArray(
-        '522dc1f099567d07f47f37a32a84427d643a8cdcbfe5c0c97598a2bd2555d1aa8cb08e48590dbb3da7b' +
-          '08b1056828838c5f61e6393ba7a0abcc9f662',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('76fc6ece0f4e1768cddf8853bb2d551b', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 17', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray('cafebabefacedbad', 'hex'),
-      toArray(
-        'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
-        'hex'
-      )
-    )
+    const output = AESGCM(plainText, iv, key)
 
     expect(
       toArray(
-        'c3762df1ca787d32ae47c13bf19844cbaf1ae14d0b976afac52ff7d79bba9de0feb582d33934a4f0954' +
-          'cc2363bc73f7862ac430e64abe499f47c9b1f',
-        'hex'
-      )
-    ).toEqual(output.result)
-    expect(toArray('3a337dbf46a792c45e454913fe2ea8f2', 'hex')).toEqual(
-      output.authenticationTag
-    )
-  })
-
-  it('should encrypt: Test Case 18', () => {
-    const output = AESGCM(
-      toArray(
-        'd9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956' +
-          '809532fcf0e2449a6b525b16aedf5aa0de657ba637b39',
-        'hex'
-      ),
-      toArray('feedfacedeadbeeffeedfacedeadbeefabaddad2', 'hex'),
-      toArray(
-        '9313225df88406e555909c5aff5269aa6a7a9538534f7da1e4c303d2a318a728c3c0c95156809539fcf0e2429a6b525416' +
-          'aedbf5a0de6a57a637b39b',
-        'hex'
-      ),
-      toArray(
-        'feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308',
-        'hex'
-      )
-    )
-
-    expect(
-      toArray(
-        '5a8def2f0c9e53f1f75d7853659e2a20eeb2b22aafde6419a058ab4f6f746bf40fc0c3b780f244452da' +
-          '3ebf1c5d82cdea2418997200ef82e44ae7e3f',
+        '522dc1f099567d07f47f37a32a84427d643a8cdcbfe5c0c97598a2bd2555d1aa8cb08e48590dbb3da7b' +
+          '08b1056828838c5f61e6393ba7a0abcc9f662898015ad',
         'hex'
       )
-    ).toEqual(output.result)
-    expect(toArray('a44a8266ee1c8eb0c8b5d4cf5ae9f19a', 'hex')).toEqual(
-      output.authenticationTag
+    ).toEqual(Array.from(output.result))
+    expect(toArray('b094dac5d93471bdec1a502270e3cc6c', 'hex')).toEqual(
+      Array.from(output.authenticationTag)
     )
   })
 })
 
 describe('exclusiveOR', () => {
   it('should exclusiveOR', () => {
+    const out1 = exclusiveOR(
+      new Uint8Array([
+        0xf0, 0xf8, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00
+      ]),
+      new Uint8Array([0x0f, 0x0f, 0x00, 0xf0])
+    )
+
     expect([
       0xff, 0xf7, 0x7f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00
-    ]).toEqual(
-      exclusiveOR(
-        [
-          0xf0, 0xf8, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-          0x00, 0x00, 0x00, 0x00, 0x00
-        ],
-        [0x0f, 0x0f, 0x00, 0xf0]
-      )
-    )
+    ]).toEqual(Array.from(out1))
 
-    expect([0xff, 0xf7, 0x7f, 0x0f]).toEqual(
-      exclusiveOR([0xf0, 0xf8, 0x7f, 0xff], [0x0f, 0x0f, 0x00, 0xf0])
+    const out2 = exclusiveOR(
+      new Uint8Array([0xf0, 0xf8, 0x7f, 0xff]),
+      new Uint8Array([0x0f, 0x0f, 0x00, 0xf0])
     )
+
+    expect([0xff, 0xf7, 0x7f, 0x0f]).toEqual(Array.from(out2))
   })
 })
 
 describe('rightShift', () => {
   it('should rightShift', () => {
+    const input = new Uint8Array(
+      toArray('7b5b54657374566563746f725d53475d', 'hex')
+    )
+    const out = rightShift(input)
+
     expect(toArray('3dadaa32b9ba2b32b1ba37b92ea9a3ae', 'hex')).toEqual(
-      rightShift(toArray('7b5b54657374566563746f725d53475d', 'hex'))
+      Array.from(out)
     )
   })
 })
 
 describe('multiply', () => {
   it('should multiply', () => {
+    const a = new Uint8Array(
+      toArray('952b2a56a5604ac0b32b6656a05b40b6', 'hex')
+    )
+    const b = new Uint8Array(
+      toArray('dfa6bf4ded81db03ffcaff95f830f061', 'hex')
+    )
+    const out = multiply(a, b)
+
     expect(toArray('da53eb0ad2c55bb64fc4802cc3feda60', 'hex')).toEqual(
-      multiply(
-        toArray('952b2a56a5604ac0b32b6656a05b40b6', 'hex'),
-        toArray('dfa6bf4ded81db03ffcaff95f830f061', 'hex')
-      )
+      Array.from(out)
     )
   })
 
   it('should commutatively multiply', () => {
-    expect(
-      multiply(
-        toArray('48692853686179295b477565726f6e5d', 'hex'),
-        toArray('7b5b54657374566563746f725d53475d', 'hex')
-      )
-    ).toEqual(
-      multiply(
-        toArray('7b5b54657374566563746f725d53475d', 'hex'),
-        toArray('48692853686179295b477565726f6e5d', 'hex')
-      )
+    const x = new Uint8Array(
+      toArray('48692853686179295b477565726f6e5d', 'hex')
     )
+    const y = new Uint8Array(
+      toArray('7b5b54657374566563746f725d53475d', 'hex')
+    )
+
+    const out1 = multiply(x, y)
+    const out2 = multiply(y, x)
+
+    expect(Array.from(out1)).toEqual(Array.from(out2))
   })
 })
 
 describe('incrementLeastSignificantThirtyTwoBits', () => {
   it('should incrementLeastSignificantThirtyTwoBits', () => {
+    const in1 = new Uint8Array(
+      toArray('00000000000000000000000000000000', 'hex')
+    )
+    const out1 = incrementLeastSignificantThirtyTwoBits(in1)
     expect(toArray('00000000000000000000000000000001', 'hex')).toEqual(
-      incrementLeastSignificantThirtyTwoBits(
-        toArray('00000000000000000000000000000000', 'hex')
-      )
+      Array.from(out1)
     )
+
+    const in2 = new Uint8Array(
+      toArray('000000000000000000000000000000ff', 'hex')
+    )
+    const out2 = incrementLeastSignificantThirtyTwoBits(in2)
     expect(toArray('00000000000000000000000000000100', 'hex')).toEqual(
-      incrementLeastSignificantThirtyTwoBits(
-        toArray('000000000000000000000000000000ff', 'hex')
-      )
+      Array.from(out2)
     )
+
+    const in3 = new Uint8Array(
+      toArray('00000000000000000000000000ffffff', 'hex')
+    )
+    const out3 = incrementLeastSignificantThirtyTwoBits(in3)
     expect(toArray('00000000000000000000000001000000', 'hex')).toEqual(
-      incrementLeastSignificantThirtyTwoBits(
-        toArray('00000000000000000000000000ffffff', 'hex')
-      )
+      Array.from(out3)
     )
+
+    const in4 = new Uint8Array(
+      toArray('000000000000000000000000ffffffff', 'hex')
+    )
+    const out4 = incrementLeastSignificantThirtyTwoBits(in4)
     expect(toArray('00000000000000000000000000000000', 'hex')).toEqual(
-      incrementLeastSignificantThirtyTwoBits(
-        toArray('000000000000000000000000ffffffff', 'hex')
-      )
+      Array.from(out4)
     )
   })
 })
@@ -574,7 +406,9 @@ describe('checkBit', () => {
     let i
     let j
     let k = 0
-    let block = toArray('7b5b54657374566563746f725d53475d', 'hex')
+    let block = new Uint8Array(
+      toArray('7b5b54657374566563746f725d53475d', 'hex')
+    ) as any
     const expected = [
       0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0,
       1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1,
@@ -587,12 +421,12 @@ describe('checkBit', () => {
 
     for (i = 0; i < 16; i++) {
       for (j = 7; j !== -1; j--) {
-        expect(expected[k++]).toEqual(checkBit(block, i, j))
+        expect(expected[k++]).toEqual(checkBit(Array.from(block), i, j))
       }
     }
 
     for (i = 0; i < 128; i++) {
-      expect(expectedLSB[i]).toEqual(checkBit(block, 15, 0))
+      expect(expectedLSB[i]).toEqual(checkBit(Array.from(block), 15, 0))
       block = rightShift(block)
     }
   })
@@ -645,56 +479,122 @@ describe('getBytes', () => {
 })
 
 describe('AESGCM IV validation', () => {
-  const key = new Array(16).fill(0x01)
-  const aad: number[] = []
-  const plaintext = [1, 2, 3, 4]
+  const key = new Uint8Array(new Array(16).fill(0x01))
+  const plaintext = new Uint8Array([1, 2, 3, 4])
 
   it('AESGCM throws when IV is empty', () => {
     expect(() => {
-      AESGCM(plaintext, aad, [], key)
+      AESGCM(plaintext, new Uint8Array(), key)
     }).toThrow(new Error('Initialization vector must not be empty'))
   })
 
   it('AESGCMDecrypt throws when IV is empty', () => {
-    const iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
-    const { result: ciphertext, authenticationTag } = AESGCM(plaintext, aad, iv, key)
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+    const { result: ciphertext, authenticationTag } = AESGCM(
+      plaintext,
+      iv,
+      key
+    )
 
     // Now call decrypt but with an empty IV – this should be rejected
     expect(() => {
-      AESGCMDecrypt(ciphertext, aad, [], authenticationTag, key)
+      AESGCMDecrypt(ciphertext, new Uint8Array(), authenticationTag, key)
     }).toThrow(new Error('Initialization vector must not be empty'))
   })
 
   it('AESGCM throws when key is empty', () => {
-    const iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
 
     expect(() => {
-      AESGCM(plaintext, aad, iv, [])
+      AESGCM(plaintext, iv, new Uint8Array())
     }).toThrow(new Error('Key must not be empty'))
   })
 
   it('AESGCMDecrypt throws when key is empty', () => {
-    const iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
-    const { result: ciphertext, authenticationTag } = AESGCM(plaintext, aad, iv, key)
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+    const { result: ciphertext, authenticationTag } = AESGCM(
+      plaintext,
+      iv,
+      key
+    )
 
     expect(() => {
-      AESGCMDecrypt(ciphertext, aad, iv, authenticationTag, [])
+      AESGCMDecrypt(
+        ciphertext,
+        iv,
+        authenticationTag,
+        new Uint8Array()
+      )
     }).toThrow(new Error('Key must not be empty'))
   })
 
   it('AESGCMDecrypt throws when cipher text is empty', () => {
-    const iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
 
     expect(() => {
-      AESGCMDecrypt([], aad, iv, [], key)
+      AESGCMDecrypt(new Uint8Array(), iv, new Uint8Array(), key)
     }).toThrow(new Error('Cipher text must not be empty'))
   })
 
   it('AESGCM still work with a valid IV', () => {
-    const iv = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
-    const { result: ciphertext, authenticationTag } = AESGCM(plaintext, aad, iv, key)
-    const decrypted = AESGCMDecrypt(ciphertext, aad, iv, authenticationTag, key)
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+    const { result: ciphertext, authenticationTag } = AESGCM(
+      plaintext,
+      iv,
+      key
+    )
+    const decrypted = AESGCMDecrypt(
+      ciphertext,
+      iv,
+      authenticationTag,
+      key
+    ) as Uint8Array
+
+    expect(Array.from(decrypted)).toEqual(Array.from(plaintext))
+  })
+})
+
+function expectUint8ArrayEqual (a: Uint8Array, b: Uint8Array) {
+  expect(a.length).toBe(b.length)
 
-    expect(decrypted).toEqual(plaintext)
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      throw new Error(`mismatch at index ${i}: ${a[i]} !== ${b[i]}`)
+    }
+  }
+}
+
+describe('AESGCM large input (non-mocked)', () => {
+  // NOTE: This test is intentionally skipped by default because it allocates
+  // ~500MB+ and will be very slow / memory-heavy.
+  // Un-skip locally when you want to manually verify behavior for lengths
+  // larger than 2^32 bits.
+  it.skip('handles ciphertext longer than 2^32 bits', () => {
+    const key = new Uint8Array(new Array(16).fill(0x01))
+    const iv = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+
+    // 2^32 bits = 2^29 bytes. Go just beyond that boundary.
+    const bigSizeBytes = (1 << 29) + 16 // 2^29 + 16 bytes (> 2^32 bits)
+
+    // Use a typed array instead of a giant sparse JS array.
+    const plaintext = new Uint8Array(bigSizeBytes) // already zero-initialized
+
+    const { result: ciphertext, authenticationTag } = AESGCM(
+      plaintext,
+      iv,
+      key
+    )
+
+    const decrypted = AESGCMDecrypt(
+      ciphertext,
+      iv,
+      authenticationTag,
+      key
+    ) as Uint8Array | null
+
+    expect(decrypted).not.toBeNull()
+    const decryptedBytes = decrypted as Uint8Array
+    expect(decryptedBytes.length).toBe(bigSizeBytes)
+    expectUint8ArrayEqual(decryptedBytes, plaintext)
   })
 })