@dynamic-labs/utils 4.9.8 → 4.9.9

package/CHANGELOG.md

@@ -1,4 +1,16 @@
 
+### [4.9.9](https://github.com/dynamic-labs/dynamic-auth/compare/v4.9.8...v4.9.9) (2025-03-26)
+
+
+### Bug Fixes
+
+* **global-wallet-client:** properly clean up the popup state when popup is closed ([#8379](https://github.com/dynamic-labs/dynamic-auth/issues/8379)) ([782963f](https://github.com/dynamic-labs/dynamic-auth/commit/782963f87fcb2658b921ff6cc6f22c63be9714fb))
+* hanging promises when a starknet wallet is connected but locked ([#8376](https://github.com/dynamic-labs/dynamic-auth/issues/8376)) ([a753939](https://github.com/dynamic-labs/dynamic-auth/commit/a7539395d4653be49f000ae51d15347a176b5b6c))
+* token balance list should respect sort from backend ([#8383](https://github.com/dynamic-labs/dynamic-auth/issues/8383)) ([1c3bef4](https://github.com/dynamic-labs/dynamic-auth/commit/1c3bef47dbfd319e2444368a4a503b0839b5ad4b))
+
+
+* add message auth code to global wallet ([#8354](https://github.com/dynamic-labs/dynamic-auth/issues/8354)) ([c847bf8](https://github.com/dynamic-labs/dynamic-auth/commit/c847bf8d66db54534348622255997f30f4309542))
+
 ### [4.9.8](https://github.com/dynamic-labs/dynamic-auth/compare/v4.9.7...v4.9.8) (2025-03-24)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.9.8";
+var version = "4.9.9";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.9.8";
+var version = "4.9.9";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/utils",
-  "version": "4.9.8",
+  "version": "4.9.9",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -20,9 +20,9 @@
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.0.644",
     "tldts": "6.0.16",
-    "@dynamic-labs/assert-package-version": "4.9.8",
-    "@dynamic-labs/logger": "4.9.8",
-    "@dynamic-labs/types": "4.9.8",
+    "@dynamic-labs/assert-package-version": "4.9.9",
+    "@dynamic-labs/logger": "4.9.9",
+    "@dynamic-labs/types": "4.9.9",
     "buffer": "6.0.3",
     "eventemitter3": "5.0.1"
   },

package/src/encryption/decryptMessage/decryptMessage.cjs

@@ -11,16 +11,24 @@ var _tslib = require('../../../_virtual/_tslib.cjs');
  * @param sharedSecret - The shared secret key in hexadecimal format
  * @param message - The encrypted message in base64 format
  * @param iv - The initialization vector in hexadecimal format
+ * @param additionalData - Additional data to include in the decryption
  * @returns A Promise that resolves to the decrypted message as a string
  */
-const decryptMessage = (sharedSecret, message, iv) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+const decryptMessage = (sharedSecret, message, iv, additionalData) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const decoder = new TextDecoder();
     const sharedSecretByteArray = new Uint8Array((_b = (_a = decodeURIComponent(sharedSecret)
         .match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((byte) => parseInt(byte, 16))) !== null && _b !== void 0 ? _b : []);
     // Import the ArrayBuffer as a CryptoKey
     const sharedSecretCryptoKey = yield crypto.subtle.importKey('raw', sharedSecretByteArray.buffer, 'AES-GCM', true, ['encrypt', 'decrypt']);
-    const decryptedData = yield crypto.subtle.decrypt({ iv: hexToUint8Array(decodeURIComponent(iv)), name: 'AES-GCM' }, sharedSecretCryptoKey, base64ToArrayBuffer(decodeURIComponent(message)));
+    const decryptParams = {
+        iv: hexToUint8Array(decodeURIComponent(iv)),
+        name: 'AES-GCM',
+    };
+    if (additionalData) {
+        decryptParams.additionalData = additionalData;
+    }
+    const decryptedData = yield crypto.subtle.decrypt(decryptParams, sharedSecretCryptoKey, base64ToArrayBuffer(decodeURIComponent(message)));
     return decoder.decode(new Uint8Array(decryptedData));
 });
 const hexToUint8Array = (hex) => {

package/src/encryption/decryptMessage/decryptMessage.d.ts

@@ -4,6 +4,7 @@
  * @param sharedSecret - The shared secret key in hexadecimal format
  * @param message - The encrypted message in base64 format
  * @param iv - The initialization vector in hexadecimal format
+ * @param additionalData - Additional data to include in the decryption
  * @returns A Promise that resolves to the decrypted message as a string
  */
-export declare const decryptMessage: (sharedSecret: string, message: string, iv: string) => Promise<string>;
+export declare const decryptMessage: (sharedSecret: string, message: string, iv: string, additionalData?: BufferSource) => Promise<string>;

package/src/encryption/decryptMessage/decryptMessage.js

@@ -7,16 +7,24 @@ import { __awaiter } from '../../../_virtual/_tslib.js';
  * @param sharedSecret - The shared secret key in hexadecimal format
  * @param message - The encrypted message in base64 format
  * @param iv - The initialization vector in hexadecimal format
+ * @param additionalData - Additional data to include in the decryption
  * @returns A Promise that resolves to the decrypted message as a string
  */
-const decryptMessage = (sharedSecret, message, iv) => __awaiter(void 0, void 0, void 0, function* () {
+const decryptMessage = (sharedSecret, message, iv, additionalData) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const decoder = new TextDecoder();
     const sharedSecretByteArray = new Uint8Array((_b = (_a = decodeURIComponent(sharedSecret)
         .match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((byte) => parseInt(byte, 16))) !== null && _b !== void 0 ? _b : []);
     // Import the ArrayBuffer as a CryptoKey
     const sharedSecretCryptoKey = yield crypto.subtle.importKey('raw', sharedSecretByteArray.buffer, 'AES-GCM', true, ['encrypt', 'decrypt']);
-    const decryptedData = yield crypto.subtle.decrypt({ iv: hexToUint8Array(decodeURIComponent(iv)), name: 'AES-GCM' }, sharedSecretCryptoKey, base64ToArrayBuffer(decodeURIComponent(message)));
+    const decryptParams = {
+        iv: hexToUint8Array(decodeURIComponent(iv)),
+        name: 'AES-GCM',
+    };
+    if (additionalData) {
+        decryptParams.additionalData = additionalData;
+    }
+    const decryptedData = yield crypto.subtle.decrypt(decryptParams, sharedSecretCryptoKey, base64ToArrayBuffer(decodeURIComponent(message)));
     return decoder.decode(new Uint8Array(decryptedData));
 });
 const hexToUint8Array = (hex) => {

package/src/encryption/encryptMessage/encryptMessage.cjs

@@ -9,11 +9,12 @@ var _tslib = require('../../../_virtual/_tslib.cjs');
  * Encrypts a message using AES-GCM encryption with a shared secret key
  * @param sharedSecret - Hexadecimal string representing the shared secret key
  * @param message - The plaintext message to encrypt
- * @returns {Promise<{encryptedMessage: string, iv: string}>} Object containing:
+ * @param additionalData - Additional data to include in the encryption
+ * @returns Object containing:
  *   - encryptedMessage: Base64 encoded encrypted message
  *   - iv: Hexadecimal initialization vector used for encryption
  */
-const encryptMessage = (sharedSecret, message) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+const encryptMessage = (sharedSecret, message, additionalData) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const encoder = new TextEncoder();
     const iv = crypto.getRandomValues(new Uint8Array(12));
@@ -21,7 +22,14 @@ const encryptMessage = (sharedSecret, message) => _tslib.__awaiter(void 0, void
     const sharedSecretByteArray = new Uint8Array((_b = (_a = sharedSecret.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((byte) => parseInt(byte, 16))) !== null && _b !== void 0 ? _b : []);
     // Import the ArrayBuffer as a CryptoKey
     const sharedSecretCryptoKey = yield crypto.subtle.importKey('raw', sharedSecretByteArray.buffer, 'AES-GCM', true, ['encrypt', 'decrypt']);
-    const encryptedMessage = yield crypto.subtle.encrypt({ iv, name: 'AES-GCM' }, sharedSecretCryptoKey, data);
+    const encryptParams = {
+        iv,
+        name: 'AES-GCM',
+    };
+    if (additionalData) {
+        encryptParams.additionalData = additionalData;
+    }
+    const encryptedMessage = yield crypto.subtle.encrypt(encryptParams, sharedSecretCryptoKey, data);
     return {
         encryptedMessage: encodeURIComponent(arrayBufferToBase64(encryptedMessage)),
         iv: encodeURIComponent(uint8ArrayToHex(iv)),

package/src/encryption/encryptMessage/encryptMessage.d.ts

@@ -6,8 +6,9 @@ export type EncryptedMessage = {
  * Encrypts a message using AES-GCM encryption with a shared secret key
  * @param sharedSecret - Hexadecimal string representing the shared secret key
  * @param message - The plaintext message to encrypt
- * @returns {Promise<{encryptedMessage: string, iv: string}>} Object containing:
+ * @param additionalData - Additional data to include in the encryption
+ * @returns Object containing:
  *   - encryptedMessage: Base64 encoded encrypted message
  *   - iv: Hexadecimal initialization vector used for encryption
  */
-export declare const encryptMessage: (sharedSecret: string, message: string) => Promise<EncryptedMessage>;
+export declare const encryptMessage: (sharedSecret: string, message: string, additionalData?: BufferSource) => Promise<EncryptedMessage>;

package/src/encryption/encryptMessage/encryptMessage.js

@@ -5,11 +5,12 @@ import { __awaiter } from '../../../_virtual/_tslib.js';
  * Encrypts a message using AES-GCM encryption with a shared secret key
  * @param sharedSecret - Hexadecimal string representing the shared secret key
  * @param message - The plaintext message to encrypt
- * @returns {Promise<{encryptedMessage: string, iv: string}>} Object containing:
+ * @param additionalData - Additional data to include in the encryption
+ * @returns Object containing:
  *   - encryptedMessage: Base64 encoded encrypted message
  *   - iv: Hexadecimal initialization vector used for encryption
  */
-const encryptMessage = (sharedSecret, message) => __awaiter(void 0, void 0, void 0, function* () {
+const encryptMessage = (sharedSecret, message, additionalData) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const encoder = new TextEncoder();
     const iv = crypto.getRandomValues(new Uint8Array(12));
@@ -17,7 +18,14 @@ const encryptMessage = (sharedSecret, message) => __awaiter(void 0, void 0, void
     const sharedSecretByteArray = new Uint8Array((_b = (_a = sharedSecret.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((byte) => parseInt(byte, 16))) !== null && _b !== void 0 ? _b : []);
     // Import the ArrayBuffer as a CryptoKey
     const sharedSecretCryptoKey = yield crypto.subtle.importKey('raw', sharedSecretByteArray.buffer, 'AES-GCM', true, ['encrypt', 'decrypt']);
-    const encryptedMessage = yield crypto.subtle.encrypt({ iv, name: 'AES-GCM' }, sharedSecretCryptoKey, data);
+    const encryptParams = {
+        iv,
+        name: 'AES-GCM',
+    };
+    if (additionalData) {
+        encryptParams.additionalData = additionalData;
+    }
+    const encryptedMessage = yield crypto.subtle.encrypt(encryptParams, sharedSecretCryptoKey, data);
     return {
         encryptedMessage: encodeURIComponent(arrayBufferToBase64(encryptedMessage)),
         iv: encodeURIComponent(uint8ArrayToHex(iv)),

package/src/encryption/generateHMAC/generateHMAC.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var assertDefined = require('../../assertDefined/assertDefined.cjs');
+
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using SHA-256
+ *
+ * @param keyData - The secret key used for generating the HMAC
+ * @param data - The data to be authenticated
+ * @returns A hexadecimal string representation of the HMAC
+ *
+ * @example
+ * const hmac = await generateHMAC('secretKey', 'dataToAuthenticate');
+ * console.log(hmac); // outputs: "a1b2c3d4..."
+ */
+const generateHMAC = (keyData, data) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    assertDefined.assertDefined(keyData, 'Key data must be a non-empty string');
+    assertDefined.assertDefined(data, 'Data must be a non-empty string');
+    const textEncoder = new TextEncoder();
+    const encodedKeyData = textEncoder.encode(keyData);
+    const encodedData = textEncoder.encode(data);
+    // Import the key for HMAC using SHA-256
+    const key = yield crypto.subtle.importKey('raw', encodedKeyData, { hash: 'SHA-256', name: 'HMAC' }, false, ['sign']);
+    // Generate the HMAC signature for the data
+    const signature = yield crypto.subtle.sign('HMAC', key, encodedData);
+    // Convert the ArrayBuffer signature into a hex string
+    const hashArray = Array.from(new Uint8Array(signature));
+    const hashHex = hashArray
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return hashHex;
+});
+
+exports.generateHMAC = generateHMAC;

package/src/encryption/generateHMAC/generateHMAC.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using SHA-256
+ *
+ * @param keyData - The secret key used for generating the HMAC
+ * @param data - The data to be authenticated
+ * @returns A hexadecimal string representation of the HMAC
+ *
+ * @example
+ * const hmac = await generateHMAC('secretKey', 'dataToAuthenticate');
+ * console.log(hmac); // outputs: "a1b2c3d4..."
+ */
+export declare const generateHMAC: (keyData: string, data: string) => Promise<string>;

package/src/encryption/generateHMAC/generateHMAC.js

@@ -0,0 +1,34 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { assertDefined } from '../../assertDefined/assertDefined.js';
+
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using SHA-256
+ *
+ * @param keyData - The secret key used for generating the HMAC
+ * @param data - The data to be authenticated
+ * @returns A hexadecimal string representation of the HMAC
+ *
+ * @example
+ * const hmac = await generateHMAC('secretKey', 'dataToAuthenticate');
+ * console.log(hmac); // outputs: "a1b2c3d4..."
+ */
+const generateHMAC = (keyData, data) => __awaiter(void 0, void 0, void 0, function* () {
+    assertDefined(keyData, 'Key data must be a non-empty string');
+    assertDefined(data, 'Data must be a non-empty string');
+    const textEncoder = new TextEncoder();
+    const encodedKeyData = textEncoder.encode(keyData);
+    const encodedData = textEncoder.encode(data);
+    // Import the key for HMAC using SHA-256
+    const key = yield crypto.subtle.importKey('raw', encodedKeyData, { hash: 'SHA-256', name: 'HMAC' }, false, ['sign']);
+    // Generate the HMAC signature for the data
+    const signature = yield crypto.subtle.sign('HMAC', key, encodedData);
+    // Convert the ArrayBuffer signature into a hex string
+    const hashArray = Array.from(new Uint8Array(signature));
+    const hashHex = hashArray
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return hashHex;
+});
+
+export { generateHMAC };

package/src/encryption/generateHMAC/index.d.ts

@@ -0,0 +1 @@
+export { generateHMAC } from './generateHMAC';

package/src/encryption/index.d.ts

@@ -4,4 +4,5 @@ export { convertPublicKeyCryptoKeyToHex } from './convertPublicKeyCryptoKeyToHex
 export { convertPublicKeyHexToCryptoKey } from './convertPublicKeyHexToCryptoKey';
 export { decryptMessage } from './decryptMessage';
 export { encryptMessage, type EncryptedMessage } from './encryptMessage';
+export { generateHMAC } from './generateHMAC';
 export { isEncryptedMessage } from './isEncryptedMessage';

package/src/index.cjs

@@ -78,6 +78,7 @@ var convertPublicKeyCryptoKeyToHex = require('./encryption/convertPublicKeyCrypt
 var convertPublicKeyHexToCryptoKey = require('./encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.cjs');
 var decryptMessage = require('./encryption/decryptMessage/decryptMessage.cjs');
 var encryptMessage = require('./encryption/encryptMessage/encryptMessage.cjs');
+var generateHMAC = require('./encryption/generateHMAC/generateHMAC.cjs');
 var isEncryptedMessage = require('./encryption/isEncryptedMessage/isEncryptedMessage.cjs');
 var uint8ArrayToBase64 = require('./uint8ArrayToBase64/uint8ArrayToBase64.cjs');
 var assertDefined = require('./assertDefined/assertDefined.cjs');
@@ -200,6 +201,7 @@ exports.convertPublicKeyCryptoKeyToHex = convertPublicKeyCryptoKeyToHex.convertP
 exports.convertPublicKeyHexToCryptoKey = convertPublicKeyHexToCryptoKey.convertPublicKeyHexToCryptoKey;
 exports.decryptMessage = decryptMessage.decryptMessage;
 exports.encryptMessage = encryptMessage.encryptMessage;
+exports.generateHMAC = generateHMAC.generateHMAC;
 exports.isEncryptedMessage = isEncryptedMessage.isEncryptedMessage;
 exports.uint8ArrayFromBase64 = uint8ArrayToBase64.uint8ArrayFromBase64;
 exports.uint8ArrayToBase64 = uint8ArrayToBase64.uint8ArrayToBase64;

package/src/index.js

@@ -74,6 +74,7 @@ export { convertPublicKeyCryptoKeyToHex } from './encryption/convertPublicKeyCry
 export { convertPublicKeyHexToCryptoKey } from './encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.js';
 export { decryptMessage } from './encryption/decryptMessage/decryptMessage.js';
 export { encryptMessage } from './encryption/encryptMessage/encryptMessage.js';
+export { generateHMAC } from './encryption/generateHMAC/generateHMAC.js';
 export { isEncryptedMessage } from './encryption/isEncryptedMessage/isEncryptedMessage.js';
 export { uint8ArrayFromBase64, uint8ArrayToBase64 } from './uint8ArrayToBase64/uint8ArrayToBase64.js';
 export { assertDefined } from './assertDefined/assertDefined.js';