feat: native C++ encoding/decoding for hex, base64, and more (#967)

Author: boorad

example/src/benchmarks/encoding/encoding.ts

@@ -0,0 +1,213 @@
+import {
+  bufferToString,
+  stringToBuffer,
+  Buffer as CraftzdogBuffer,
+} from 'react-native-quick-crypto';
+import type { BenchFn } from '../../types/benchmarks';
+import { Bench } from 'tinybench';
+
+function ab2str_old(buf: ArrayBuffer, encoding: string = 'hex'): string {
+  return CraftzdogBuffer.from(buf).toString(encoding);
+}
+
+function stringToBuffer_old(
+  input: string,
+  encoding: string = 'utf-8',
+): ArrayBuffer {
+  const buffer = CraftzdogBuffer.from(input, encoding);
+  return buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength,
+  );
+}
+
+// Generate test data
+const generate1MB = (): ArrayBuffer => {
+  const bytes = new Uint8Array(1024 * 1024);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = i & 0xff;
+  }
+  return bytes.buffer as ArrayBuffer;
+};
+
+const ab1MB = generate1MB();
+const ab32B = new Uint8Array(32).buffer as ArrayBuffer; // typical hash digest size
+// Fill 32B with non-zero data
+new Uint8Array(ab32B).set([
+  0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0xba, 0xbe, 0x01, 0x23, 0x45, 0x67, 0x89,
+  0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x11, 0x22,
+  0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
+]);
+
+// Pre-encode strings for decode benchmarks
+const hex1MB = bufferToString(ab1MB, 'hex');
+const base64_1MB = bufferToString(ab1MB, 'base64');
+const hex32B = bufferToString(ab32B, 'hex');
+const base64_32B = bufferToString(ab32B, 'base64');
+
+// --- Encode benchmarks (ArrayBuffer → string) ---
+
+const encode_hex_32b: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hex encode 32B (digest size)',
+    iterations: 100,
+    warmupIterations: 10,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      bufferToString(ab32B, 'hex');
+    })
+    .add('Buffer polyfill', () => {
+      ab2str_old(ab32B, 'hex');
+    });
+
+  return bench;
+};
+
+const encode_hex_1mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hex encode 1MB',
+    iterations: 10,
+    warmupIterations: 2,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      bufferToString(ab1MB, 'hex');
+    })
+    .add('Buffer polyfill', () => {
+      ab2str_old(ab1MB, 'hex');
+    });
+
+  return bench;
+};
+
+const encode_base64_32b: BenchFn = () => {
+  const bench = new Bench({
+    name: 'base64 encode 32B (digest size)',
+    iterations: 100,
+    warmupIterations: 10,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      bufferToString(ab32B, 'base64');
+    })
+    .add('Buffer polyfill', () => {
+      ab2str_old(ab32B, 'base64');
+    });
+
+  return bench;
+};
+
+const encode_base64_1mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'base64 encode 1MB',
+    iterations: 10,
+    warmupIterations: 2,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      bufferToString(ab1MB, 'base64');
+    })
+    .add('Buffer polyfill', () => {
+      ab2str_old(ab1MB, 'base64');
+    });
+
+  return bench;
+};
+
+// --- Decode benchmarks (string → ArrayBuffer) ---
+
+const decode_hex_32b: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hex decode 32B',
+    iterations: 100,
+    warmupIterations: 10,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      stringToBuffer(hex32B, 'hex');
+    })
+    .add('Buffer polyfill', () => {
+      stringToBuffer_old(hex32B, 'hex');
+    });
+
+  return bench;
+};
+
+const decode_hex_1mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'hex decode 1MB',
+    iterations: 10,
+    warmupIterations: 2,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      stringToBuffer(hex1MB, 'hex');
+    })
+    .add('Buffer polyfill', () => {
+      stringToBuffer_old(hex1MB, 'hex');
+    });
+
+  return bench;
+};
+
+const decode_base64_32b: BenchFn = () => {
+  const bench = new Bench({
+    name: 'base64 decode 32B',
+    iterations: 100,
+    warmupIterations: 10,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      stringToBuffer(base64_32B, 'base64');
+    })
+    .add('Buffer polyfill', () => {
+      stringToBuffer_old(base64_32B, 'base64');
+    });
+
+  return bench;
+};
+
+const decode_base64_1mb: BenchFn = () => {
+  const bench = new Bench({
+    name: 'base64 decode 1MB',
+    iterations: 10,
+    warmupIterations: 2,
+    time: 0,
+  });
+
+  bench
+    .add('rnqc', () => {
+      stringToBuffer(base64_1MB, 'base64');
+    })
+    .add('Buffer polyfill', () => {
+      stringToBuffer_old(base64_1MB, 'base64');
+    });
+
+  return bench;
+};
+
+export default [
+  encode_hex_32b,
+  encode_hex_1mb,
+  encode_base64_32b,
+  encode_base64_1mb,
+  decode_hex_32b,
+  decode_hex_1mb,
+  decode_base64_32b,
+  decode_base64_1mb,
+];

example/src/hooks/useBenchmarks.ts

@@ -11,6 +11,7 @@ import ecdh from '../benchmarks/ecdh/ecdh';
 import dh from '../benchmarks/dh/dh';
 import random from '../benchmarks/random/randomBytes';
 import scrypt from '../benchmarks/scrypt/scrypt';
+import encoding from '../benchmarks/encoding/encoding';
 import xsalsa20 from '../benchmarks/cipher/xsalsa20';
 
 export const useBenchmarks = (): [
@@ -43,6 +44,11 @@ export const useBenchmarks = (): [
       }),
     );
     newSuites.push(new BenchmarkSuite('scrypt', scrypt));
+    newSuites.push(
+      new BenchmarkSuite('encoding', encoding, {
+        'Buffer polyfill': 'old CraftzdogBuffer.from/toString path',
+      }),
+    );
     setSuites(newSuites);
   }, []);
 

example/src/hooks/useTestsList.ts

@@ -44,6 +44,7 @@ import '../tests/subtle/supports';
 import '../tests/subtle/getPublicKey';
 import '../tests/subtle/wrap_unwrap';
 import '../tests/utils/utils_tests';
+import '../tests/utils/encoding_tests';
 import '../tests/x509/x509_tests';
 
 export const useTestsList = (): [