@gjsify/crypto 0.1.0

package/src/random.ts

@@ -0,0 +1,183 @@
+// Reference: Node.js lib/internal/crypto/random.js
+// Reimplemented for GJS using WebCrypto API / GLib.Random
+
+import { Buffer } from 'node:buffer';
+
+const hasWebCrypto = typeof globalThis.crypto !== 'undefined' && typeof globalThis.crypto.getRandomValues === 'function';
+
+/**
+ * Fill a Uint8Array with random bytes, using WebCrypto or GLib.Random fallback.
+ */
+function fillRandom(view: Uint8Array): void {
+  if (hasWebCrypto) {
+    // WebCrypto has a 65536-byte limit per call
+    for (let offset = 0; offset < view.length; offset += 65536) {
+      const length = Math.min(view.length - offset, 65536);
+      const slice = new Uint8Array(view.buffer as ArrayBuffer, view.byteOffset + offset, length);
+      globalThis.crypto.getRandomValues(slice);
+    }
+  } else {
+    // GLib.Random fallback for GJS environments without WebCrypto
+    try {
+      const GLib = imports.gi.GLib;
+      for (let i = 0; i < view.length; i++) {
+        view[i] = GLib.random_int_range(0, 256);
+      }
+    } catch {
+      // Last resort: Math.random (not cryptographically secure)
+      for (let i = 0; i < view.length; i++) {
+        view[i] = Math.floor(Math.random() * 256);
+      }
+    }
+  }
+}
+
+/**
+ * Generate cryptographically strong pseudo-random data.
+ */
+export function randomBytes(size: number): Buffer;
+export function randomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
+export function randomBytes(size: number, callback?: (err: Error | null, buf: Buffer) => void): Buffer | void {
+  if (typeof size !== 'number' || size < 0 || !Number.isInteger(size)) {
+    throw new TypeError(`The "size" argument must be a non-negative integer. Received ${size}`);
+  }
+
+  try {
+    const buf = Buffer.alloc(size);
+    if (size > 0) {
+      fillRandom(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+    }
+    if (callback) {
+      callback(null, buf);
+    } else {
+      return buf;
+    }
+  } catch (err) {
+    if (callback) {
+      callback(err as Error, Buffer.alloc(0));
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * Fill a buffer with cryptographically strong pseudo-random data (synchronous).
+ */
+export function randomFillSync(buffer: Buffer | Uint8Array, offset = 0, size?: number): Buffer | Uint8Array {
+  const length = size ?? (buffer.length - offset);
+
+  if (offset < 0 || offset > buffer.length) {
+    throw new RangeError(`The value of "offset" is out of range. Received ${offset}`);
+  }
+  if (length < 0 || offset + length > buffer.length) {
+    throw new RangeError(`The value of "size" is out of range. Received ${length}`);
+  }
+
+  if (length > 0) {
+    const byteOffset = buffer instanceof Buffer ? buffer.byteOffset : buffer.byteOffset;
+    const view = new Uint8Array(buffer.buffer as ArrayBuffer, byteOffset + offset, length);
+    fillRandom(view);
+  }
+
+  return buffer;
+}
+
+/**
+ * Fill a buffer with cryptographically strong pseudo-random data (async).
+ */
+export function randomFill(
+  buffer: Buffer | Uint8Array,
+  offset: number | ((err: Error | null, buf: Buffer | Uint8Array) => void),
+  size?: number | ((err: Error | null, buf: Buffer | Uint8Array) => void),
+  callback?: (err: Error | null, buf: Buffer | Uint8Array) => void,
+): void {
+  let _offset: number;
+  let _size: number;
+  let _callback: (err: Error | null, buf: Buffer | Uint8Array) => void;
+
+  if (typeof offset === 'function') {
+    _callback = offset;
+    _offset = 0;
+    _size = buffer.length;
+  } else if (typeof size === 'function') {
+    _callback = size;
+    _offset = offset;
+    _size = buffer.length - offset;
+  } else {
+    _callback = callback!;
+    _offset = offset;
+    _size = size!;
+  }
+
+  try {
+    randomFillSync(buffer, _offset, _size);
+    _callback(null, buffer);
+  } catch (err) {
+    _callback(err as Error, buffer);
+  }
+}
+
+/**
+ * Generate a random UUID v4 string.
+ */
+export function randomUUID(): string {
+  if (hasWebCrypto && typeof globalThis.crypto.randomUUID === 'function') {
+    return globalThis.crypto.randomUUID();
+  }
+
+  // Manual UUID v4 generation fallback
+  const bytes = new Uint8Array(16);
+  fillRandom(bytes);
+  // Set version (4) and variant (10xx)
+  bytes[6] = (bytes[6] & 0x0f) | 0x40;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+/**
+ * Generate a random integer between min (inclusive) and max (exclusive).
+ */
+export function randomInt(min: number, max?: number | ((err: Error | null, value: number) => void), callback?: (err: Error | null, value: number) => void): number | void {
+  let _min: number;
+  let _max: number;
+  let _callback: ((err: Error | null, value: number) => void) | undefined;
+
+  if (typeof max === 'function') {
+    _callback = max;
+    _max = min;
+    _min = 0;
+  } else if (typeof max === 'number') {
+    _min = min;
+    _max = max;
+    _callback = callback;
+  } else {
+    _max = min;
+    _min = 0;
+    _callback = callback;
+  }
+
+  if (!Number.isInteger(_min)) {
+    throw new TypeError(`The "min" argument must be a safe integer. Received ${_min}`);
+  }
+  if (!Number.isInteger(_max)) {
+    throw new TypeError(`The "max" argument must be a safe integer. Received ${_max}`);
+  }
+  if (_min >= _max) {
+    throw new RangeError(`The value of "min" must be less than "max". Received min: ${_min}, max: ${_max}`);
+  }
+
+  const range = _max - _min;
+  const bytes = new Uint32Array(1);
+  const view = new Uint8Array(bytes.buffer);
+  fillRandom(view);
+  const value = _min + (bytes[0] % range);
+
+  if (_callback) {
+    _callback(null, value);
+  } else {
+    return value;
+  }
+}

package/src/rsa-oaep.ts

@@ -0,0 +1,167 @@
+// RSA-OAEP (Optimal Asymmetric Encryption Padding) per RFC 8017 Section 7.1
+// Reference: refs/node/lib/internal/crypto/cipher.js
+// Copyright (c) Node.js contributors. MIT license.
+// Reimplemented for GJS using BigInt RSA math
+
+import { Hash } from './hash.js';
+import { randomBytes } from './random.js';
+import { mgf1 } from './mgf1.js';
+import { parsePemKey, rsaKeySize } from './asn1.js';
+import type { RsaPrivateComponents, RsaPublicComponents } from './asn1.js';
+import { hashSize } from './crypto-utils.js';
+import { modPow, bigIntToBytes, bytesToBigInt } from './bigint-math.js';
+
+function hashDigest(algo: string, data: Uint8Array): Uint8Array {
+  const h = new Hash(algo);
+  h.update(data);
+  return new Uint8Array(h.digest() as any);
+}
+
+// ---------------------------------------------------------------------------
+// RSAES-OAEP-ENCRYPT (RFC 8017 Section 7.1.1)
+// ---------------------------------------------------------------------------
+
+/**
+ * RSA-OAEP encrypt using PEM public key.
+ */
+export function rsaOaepEncrypt(
+  hashAlgo: string,
+  pubKeyPem: string,
+  plaintext: Uint8Array,
+  label?: Uint8Array,
+): Uint8Array {
+  const parsed = parsePemKey(pubKeyPem);
+  let n: bigint, e: bigint;
+  if (parsed.type === 'rsa-public') {
+    ({ n, e } = parsed.components as RsaPublicComponents);
+  } else if (parsed.type === 'rsa-private') {
+    ({ n, e } = parsed.components as RsaPrivateComponents);
+  } else {
+    throw new Error('RSA-OAEP: expected RSA key');
+  }
+
+  const keyBytes = Math.ceil(rsaKeySize(n) / 8);
+  const hLen = hashSize(hashAlgo);
+
+  if (plaintext.length > keyBytes - 2 * hLen - 2) {
+    throw new Error('RSA-OAEP: message too long');
+  }
+
+  // lHash = Hash(L) where L = label (empty by default)
+  const lHash = hashDigest(hashAlgo, label || new Uint8Array(0));
+
+  // DB = lHash || PS || 0x01 || M
+  const dbLen = keyBytes - hLen - 1;
+  const DB = new Uint8Array(dbLen);
+  DB.set(lHash, 0);
+  DB[dbLen - plaintext.length - 1] = 0x01;
+  DB.set(plaintext, dbLen - plaintext.length);
+
+  // seed = random bytes of length hLen
+  const seed = new Uint8Array(randomBytes(hLen));
+
+  // dbMask = MGF(seed, dbLen)
+  const dbMask = mgf1(hashAlgo, seed, dbLen);
+
+  // maskedDB = DB ⊕ dbMask
+  const maskedDB = new Uint8Array(dbLen);
+  for (let i = 0; i < dbLen; i++) maskedDB[i] = DB[i] ^ dbMask[i];
+
+  // seedMask = MGF(maskedDB, hLen)
+  const seedMask = mgf1(hashAlgo, maskedDB, hLen);
+
+  // maskedSeed = seed ⊕ seedMask
+  const maskedSeed = new Uint8Array(hLen);
+  for (let i = 0; i < hLen; i++) maskedSeed[i] = seed[i] ^ seedMask[i];
+
+  // EM = 0x00 || maskedSeed || maskedDB
+  const EM = new Uint8Array(keyBytes);
+  EM[0] = 0x00;
+  EM.set(maskedSeed, 1);
+  EM.set(maskedDB, 1 + hLen);
+
+  // RSAEP: c = m^e mod n
+  const m = bytesToBigInt(EM);
+  const c = modPow(m, e, n);
+  return bigIntToBytes(c, keyBytes);
+}
+
+// ---------------------------------------------------------------------------
+// RSAES-OAEP-DECRYPT (RFC 8017 Section 7.1.2)
+// ---------------------------------------------------------------------------
+
+/**
+ * RSA-OAEP decrypt using PEM private key.
+ */
+export function rsaOaepDecrypt(
+  hashAlgo: string,
+  privKeyPem: string,
+  ciphertext: Uint8Array,
+  label?: Uint8Array,
+): Uint8Array {
+  const parsed = parsePemKey(privKeyPem);
+  if (parsed.type !== 'rsa-private') throw new Error('RSA-OAEP: expected RSA private key');
+  const { n, d } = parsed.components as RsaPrivateComponents;
+
+  const keyBytes = Math.ceil(rsaKeySize(n) / 8);
+  const hLen = hashSize(hashAlgo);
+
+  if (ciphertext.length !== keyBytes || keyBytes < 2 * hLen + 2) {
+    throw new Error('RSA-OAEP: decryption error');
+  }
+
+  // RSADP: m = c^d mod n
+  const c = bytesToBigInt(ciphertext);
+  const m = modPow(c, d, n);
+  const EM = bigIntToBytes(m, keyBytes);
+
+  // Y = EM[0], maskedSeed = EM[1..hLen], maskedDB = EM[1+hLen..]
+  const Y = EM[0];
+  const maskedSeed = EM.slice(1, 1 + hLen);
+  const maskedDB = EM.slice(1 + hLen);
+  const dbLen = keyBytes - hLen - 1;
+
+  // seedMask = MGF(maskedDB, hLen)
+  const seedMask = mgf1(hashAlgo, maskedDB, hLen);
+
+  // seed = maskedSeed ⊕ seedMask
+  const seed = new Uint8Array(hLen);
+  for (let i = 0; i < hLen; i++) seed[i] = maskedSeed[i] ^ seedMask[i];
+
+  // dbMask = MGF(seed, dbLen)
+  const dbMask = mgf1(hashAlgo, seed, dbLen);
+
+  // DB = maskedDB ⊕ dbMask
+  const DB = new Uint8Array(dbLen);
+  for (let i = 0; i < dbLen; i++) DB[i] = maskedDB[i] ^ dbMask[i];
+
+  // lHash' = DB[0..hLen-1]
+  const lHash = hashDigest(hashAlgo, label || new Uint8Array(0));
+  const lHashPrime = DB.slice(0, hLen);
+
+  // Verify Y == 0 and lHash == lHash'
+  let valid = Y === 0 ? 1 : 0;
+  for (let i = 0; i < hLen; i++) {
+    valid &= (lHash[i] === lHashPrime[i]) ? 1 : 0;
+  }
+
+  // Find 0x01 separator
+  let sepIdx = -1;
+  for (let i = hLen; i < dbLen; i++) {
+    if (DB[i] === 0x01) {
+      sepIdx = i;
+      break;
+    } else if (DB[i] !== 0x00) {
+      valid = 0;
+      break;
+    }
+  }
+
+  if (sepIdx === -1) valid = 0;
+
+  if (!valid) {
+    throw new Error('RSA-OAEP: decryption error');
+  }
+
+  return DB.slice(sepIdx + 1);
+}

package/src/rsa-pss.ts

@@ -0,0 +1,190 @@
+// RSA-PSS (Probabilistic Signature Scheme) per RFC 8017 Section 8.1
+// Reference: refs/node/lib/internal/crypto/sig.js
+// Copyright (c) Node.js contributors. MIT license.
+// Reimplemented for GJS using BigInt RSA math
+
+import { Hash } from './hash.js';
+import { randomBytes } from './random.js';
+import { mgf1 } from './mgf1.js';
+import { parsePemKey, rsaKeySize } from './asn1.js';
+import type { RsaPrivateComponents, RsaPublicComponents } from './asn1.js';
+import { hashSize } from './crypto-utils.js';
+import { modPow, bigIntToBytes, bytesToBigInt } from './bigint-math.js';
+
+function hashDigest(algo: string, data: Uint8Array): Uint8Array {
+  const h = new Hash(algo);
+  h.update(data);
+  return new Uint8Array(h.digest() as any);
+}
+
+// ---------------------------------------------------------------------------
+// EMSA-PSS-ENCODE (RFC 8017 Section 9.1.1)
+// ---------------------------------------------------------------------------
+
+function emsaPssEncode(
+  mHash: Uint8Array,
+  emBits: number,
+  hashAlgo: string,
+  saltLength: number,
+): Uint8Array {
+  const hLen = hashSize(hashAlgo);
+  const emLen = Math.ceil(emBits / 8);
+
+  if (emLen < hLen + saltLength + 2) {
+    throw new Error('RSA-PSS: encoding error — key too short');
+  }
+
+  const salt = saltLength > 0 ? new Uint8Array(randomBytes(saltLength)) : new Uint8Array(0);
+
+  // M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt
+  const mPrime = new Uint8Array(8 + hLen + saltLength);
+  mPrime.set(mHash, 8);
+  mPrime.set(salt, 8 + hLen);
+
+  const H = hashDigest(hashAlgo, mPrime);
+
+  // DB = PS || 0x01 || salt (PS = zero bytes of length emLen - hLen - saltLength - 2)
+  const dbLen = emLen - hLen - 1;
+  const DB = new Uint8Array(dbLen);
+  DB[dbLen - saltLength - 1] = 0x01;
+  DB.set(salt, dbLen - saltLength);
+
+  // dbMask = MGF(H, emLen - hLen - 1)
+  const dbMask = mgf1(hashAlgo, H, dbLen);
+
+  // maskedDB = DB ⊕ dbMask
+  const maskedDB = new Uint8Array(dbLen);
+  for (let i = 0; i < dbLen; i++) maskedDB[i] = DB[i] ^ dbMask[i];
+
+  // Set leftmost (8*emLen - emBits) bits of maskedDB to zero
+  const zeroBits = 8 * emLen - emBits;
+  if (zeroBits > 0) maskedDB[0] &= (0xff >>> zeroBits);
+
+  // EM = maskedDB || H || 0xbc
+  const EM = new Uint8Array(emLen);
+  EM.set(maskedDB, 0);
+  EM.set(H, dbLen);
+  EM[emLen - 1] = 0xbc;
+
+  return EM;
+}
+
+// ---------------------------------------------------------------------------
+// EMSA-PSS-VERIFY (RFC 8017 Section 9.1.2)
+// ---------------------------------------------------------------------------
+
+function emsaPssVerify(
+  mHash: Uint8Array,
+  EM: Uint8Array,
+  emBits: number,
+  hashAlgo: string,
+  saltLength: number,
+): boolean {
+  const hLen = hashSize(hashAlgo);
+  const emLen = Math.ceil(emBits / 8);
+
+  if (emLen < hLen + saltLength + 2) return false;
+  if (EM[emLen - 1] !== 0xbc) return false;
+
+  const dbLen = emLen - hLen - 1;
+  const maskedDB = EM.slice(0, dbLen);
+  const H = EM.slice(dbLen, dbLen + hLen);
+
+  // Check leftmost bits
+  const zeroBits = 8 * emLen - emBits;
+  if (zeroBits > 0 && (maskedDB[0] & (0xff << (8 - zeroBits))) !== 0) return false;
+
+  // dbMask = MGF(H, dbLen)
+  const dbMask = mgf1(hashAlgo, H, dbLen);
+
+  // DB = maskedDB ⊕ dbMask
+  const DB = new Uint8Array(dbLen);
+  for (let i = 0; i < dbLen; i++) DB[i] = maskedDB[i] ^ dbMask[i];
+
+  // Zero leftmost bits
+  if (zeroBits > 0) DB[0] &= (0xff >>> zeroBits);
+
+  // Check PS: DB[0..dbLen-saltLength-2] should all be 0x00
+  for (let i = 0; i < dbLen - saltLength - 1; i++) {
+    if (DB[i] !== 0x00) return false;
+  }
+  if (DB[dbLen - saltLength - 1] !== 0x01) return false;
+
+  const salt = DB.slice(dbLen - saltLength);
+
+  // M' = (0x)00 00 00 00 00 00 00 00 || mHash || salt
+  const mPrime = new Uint8Array(8 + hLen + saltLength);
+  mPrime.set(mHash, 8);
+  mPrime.set(salt, 8 + hLen);
+
+  const HPrime = hashDigest(hashAlgo, mPrime);
+
+  // Compare H and H'
+  if (H.length !== HPrime.length) return false;
+  let diff = 0;
+  for (let i = 0; i < H.length; i++) diff |= H[i] ^ HPrime[i];
+  return diff === 0;
+}
+
+// ---------------------------------------------------------------------------
+// RSA-PSS Sign / Verify (operating on raw BigInt components)
+// ---------------------------------------------------------------------------
+
+/**
+ * RSA-PSS sign using PEM private key.
+ */
+export function rsaPssSign(
+  hashAlgo: string,
+  privKeyPem: string,
+  data: Uint8Array,
+  saltLength: number,
+): Uint8Array {
+  const parsed = parsePemKey(privKeyPem);
+  if (parsed.type !== 'rsa-private') throw new Error('RSA-PSS: expected RSA private key');
+  const { n, d } = parsed.components as RsaPrivateComponents;
+
+  const keyBits = rsaKeySize(n);
+  const keyBytes = Math.ceil(keyBits / 8);
+
+  const mHash = hashDigest(hashAlgo, data);
+  const EM = emsaPssEncode(mHash, keyBits - 1, hashAlgo, saltLength);
+
+  // RSASP1: s = EM^d mod n
+  const m = bytesToBigInt(EM);
+  const s = modPow(m, d, n);
+  return bigIntToBytes(s, keyBytes);
+}
+
+/**
+ * RSA-PSS verify using PEM public key.
+ */
+export function rsaPssVerify(
+  hashAlgo: string,
+  pubKeyPem: string,
+  signature: Uint8Array,
+  data: Uint8Array,
+  saltLength: number,
+): boolean {
+  const parsed = parsePemKey(pubKeyPem);
+  let n: bigint, e: bigint;
+  if (parsed.type === 'rsa-public') {
+    ({ n, e } = parsed.components as RsaPublicComponents);
+  } else if (parsed.type === 'rsa-private') {
+    ({ n, e } = parsed.components as RsaPrivateComponents);
+  } else {
+    throw new Error('RSA-PSS: expected RSA key');
+  }
+
+  const keyBits = rsaKeySize(n);
+  const keyBytes = Math.ceil(keyBits / 8);
+
+  if (signature.length !== keyBytes) return false;
+
+  // RSAVP1: m = s^e mod n
+  const s = bytesToBigInt(signature);
+  const m = modPow(s, e, n);
+  const EM = bigIntToBytes(m, Math.ceil((keyBits - 1) / 8));
+
+  const mHash = hashDigest(hashAlgo, data);
+  return emsaPssVerify(mHash, EM, keyBits - 1, hashAlgo, saltLength);
+}

package/src/scrypt.spec.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { scrypt, scryptSync } from 'node:crypto';
+import { Buffer } from 'node:buffer';
+
+export default async () => {
+  await describe('crypto.scryptSync', async () => {
+    await it('should be a function', async () => {
+      expect(typeof scryptSync).toBe('function');
+    });
+
+    await it('should derive a 64-byte key with default options', async () => {
+      const key = scryptSync('password', 'salt', 64);
+      expect(key).toBeDefined();
+      expect(key.length).toBe(64);
+      expect(key.toString('hex').substring(0, 64)).toBe(
+        '745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf773'
+      );
+    });
+
+    await it('should derive a 32-byte key', async () => {
+      const key = scryptSync('password', 'salt', 32);
+      expect(key).toBeDefined();
+      expect(key.length).toBe(32);
+    });
+
+    await it('should accept Buffer inputs', async () => {
+      const key = scryptSync(Buffer.from('password'), Buffer.from('salt'), 64);
+      expect(key.length).toBe(64);
+      // Same result as string input
+      expect(key.toString('hex').substring(0, 64)).toBe(
+        '745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf773'
+      );
+    });
+
+    await it('should match RFC 7914 test vector (N=1024, r=8, p=16)', async () => {
+      const key = scryptSync('password', 'NaCl', 64, { N: 1024, r: 8, p: 16 });
+      expect(key.toString('hex')).toBe(
+        'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640'
+      );
+    });
+
+    await it('should produce different keys for different passwords', async () => {
+      const key1 = scryptSync('password1', 'salt', 32);
+      const key2 = scryptSync('password2', 'salt', 32);
+      expect(key1.toString('hex') !== key2.toString('hex')).toBe(true);
+    });
+
+    await it('should produce different keys for different salts', async () => {
+      const key1 = scryptSync('password', 'salt1', 32);
+      const key2 = scryptSync('password', 'salt2', 32);
+      expect(key1.toString('hex') !== key2.toString('hex')).toBe(true);
+    });
+
+    await it('should accept custom cost parameter N', async () => {
+      const key = scryptSync('test', 'salt', 32, { N: 256 });
+      expect(key.length).toBe(32);
+    });
+  });
+
+  await describe('crypto.scrypt', async () => {
+    await it('should be a function', async () => {
+      expect(typeof scrypt).toBe('function');
+    });
+
+    await it('should derive key asynchronously', async () => {
+      const key = await new Promise<Buffer>((resolve, reject) => {
+        scrypt('password', 'salt', 64, (err, key) => {
+          if (err) reject(err);
+          else resolve(key);
+        });
+      });
+      expect(key.length).toBe(64);
+      expect(key.toString('hex').substring(0, 64)).toBe(
+        '745731af4484f323968969eda289aeee005b5903ac561e64a5aca121797bf773'
+      );
+    });
+
+    await it('should accept options parameter', async () => {
+      const key = await new Promise<Buffer>((resolve, reject) => {
+        scrypt('password', 'NaCl', 64, { N: 1024, r: 8, p: 16 }, (err, key) => {
+          if (err) reject(err);
+          else resolve(key);
+        });
+      });
+      expect(key.toString('hex')).toBe(
+        'fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640'
+      );
+    });
+  });
+};