Use the SHA-256 implementation built into JavaScript engines

libraries/type-length-value/js/README.md

@@ -8,7 +8,7 @@ Library with utilities for working with Type-Length-Value structures in js.
 import { TlvState, SplDiscriminator } from '@solana/spl-type-length-value';
 
 const tlv = new TlvState(tlvData, discriminatorSize, lengthSize);
-const discriminator = splDiscriminate("<discriminator-hash-input>", discriminatorSize);
+const discriminator = await splDiscriminate("<discriminator-hash-input>", discriminatorSize);
 
 const firstValue = tlv.firstBytes(discriminator);
 

libraries/type-length-value/js/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@solana/spl-type-length-value",
     "description": "SPL Type Length Value Library",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "author": "Solana Labs Maintainers <[email protected]>",
     "repository": "https://github.com/solana-labs/solana-program-library",
     "license": "Apache-2.0",
@@ -43,6 +43,7 @@
         "watch": "tsc --build --verbose --watch tsconfig.all.json"
     },
     "dependencies": {
+        "@solana/assertions": "^2.0.0-rc.1",
         "buffer": "^6.0.3"
     },
     "devDependencies": {

libraries/type-length-value/js/src/splDiscriminate.ts

@@ -1,6 +1,8 @@
-import { createHash } from 'crypto';
+import { assertDigestCapabilityIsAvailable } from '@solana/assertions';
 
-export const splDiscriminate = (discriminator: string, length = 8): Buffer => {
-    const digest = createHash('sha256').update(discriminator).digest();
-    return digest.subarray(0, length);
-};
+export async function splDiscriminate(discriminator: string, length = 8): Promise<Uint8Array> {
+    assertDigestCapabilityIsAvailable();
+    const bytes = new TextEncoder().encode(discriminator);
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return new Uint8Array(digest).subarray(0, length);
+}

libraries/type-length-value/js/test/splDiscriminate.test.ts

@@ -1,22 +1,23 @@
 import { expect } from 'chai';
 import { splDiscriminate } from '../src/splDiscriminate';
-import { createHash } from 'crypto';
 
-describe('splDiscrimintor', () => {
-    const testVectors = [
-        'hello',
-        'this-is-a-test',
-        'test-namespace:this-is-a-test',
-        'test-namespace:this-is-a-test:with-a-longer-name',
-    ];
+const testVectors = [
+    'hello',
+    'this-is-a-test',
+    'test-namespace:this-is-a-test',
+    'test-namespace:this-is-a-test:with-a-longer-name',
+];
 
-    const testExpectedBytes = testVectors.map(x => {
-        return createHash('sha256').update(x).digest();
-    });
+const testExpectedBytes = await Promise.all(
+    testVectors.map(x =>
+        crypto.subtle.digest('SHA-256', new TextEncoder().encode(x)).then(digest => new Uint8Array(digest)),
+    ),
+);
 
-    const testSplDiscriminator = (length: number) => {
+describe('splDiscrimintor', () => {
+    const testSplDiscriminator = async (length: number) => {
         for (let i = 0; i < testVectors.length; i++) {
-            const discriminator = splDiscriminate(testVectors[i], length);
+            const discriminator = await splDiscriminate(testVectors[i], length);
             const expectedBytes = testExpectedBytes[i].subarray(0, length);
             expect(discriminator).to.have.length(length);
             expect(discriminator).to.deep.equal(expectedBytes);
@@ -29,9 +30,9 @@ describe('splDiscrimintor', () => {
         testSplDiscriminator(2);
     });
 
-    it('should produce the same bytes as rust library', () => {
+    it('should produce the same bytes as rust library', async () => {
         const expectedBytes = Buffer.from([105, 37, 101, 197, 75, 251, 102, 26]);
-        const discriminator = splDiscriminate('spl-transfer-hook-interface:execute');
+        const discriminator = await splDiscriminate('spl-transfer-hook-interface:execute');
         expect(discriminator).to.deep.equal(expectedBytes);
     });
 });