@dynamic-labs/utils 4.0.0-alpha.45 → 4.0.0-alpha.47

package/CHANGELOG.md

@@ -1,4 +1,32 @@
 
+## [4.0.0-alpha.47](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.46...v4.0.0-alpha.47) (2024-12-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* stop exposing authToken and minAuthToken from dynamic context (#7629)
+
+### Bug Fixes
+
+* allow re-linking unknown wallet when there's another account of the same wallet provider already linked ([#7628](https://github.com/dynamic-labs/dynamic-auth/issues/7628)) ([20c6dc3](https://github.com/dynamic-labs/dynamic-auth/commit/20c6dc3b1847d82bd46f0df5abaef4efe1e24e38))
+* ensure wallet connector will not get removed ([#7625](https://github.com/dynamic-labs/dynamic-auth/issues/7625)) ([b764846](https://github.com/dynamic-labs/dynamic-auth/commit/b764846b56428e2997d33858e29a87f44359eb6c))
+
+
+* stop exposing authToken and minAuthToken from dynamic context ([#7629](https://github.com/dynamic-labs/dynamic-auth/issues/7629)) ([9648870](https://github.com/dynamic-labs/dynamic-auth/commit/9648870478cdcecde279117ada2a1095dab54e2c))
+
+## [4.0.0-alpha.46](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.45...v4.0.0-alpha.46) (2024-12-17)
+
+
+### Features
+
+* **GVTY-2484:** add subdomain handle field ([#7613](https://github.com/dynamic-labs/dynamic-auth/issues/7613)) ([ee8df3b](https://github.com/dynamic-labs/dynamic-auth/commit/ee8df3b34fa9fed96d92d0b414334c370c9791bc))
+
+
+### Bug Fixes
+
+* increase wait for transactions ([#7624](https://github.com/dynamic-labs/dynamic-auth/issues/7624)) ([2f7f01b](https://github.com/dynamic-labs/dynamic-auth/commit/2f7f01b024c2733f71ea0fd09dff24f815120acb))
+* solana wallet standard signer connect ([#7614](https://github.com/dynamic-labs/dynamic-auth/issues/7614)) ([1836cf3](https://github.com/dynamic-labs/dynamic-auth/commit/1836cf343b45bae01cfdcf0c0d010bf38bf54d83))
+
 ## [4.0.0-alpha.45](https://github.com/dynamic-labs/dynamic-auth/compare/v4.0.0-alpha.44...v4.0.0-alpha.45) (2024-12-11)
 
 

package/package.cjs

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

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.0.0-alpha.45";
+var version = "4.0.0-alpha.47";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/utils",
-  "version": "4.0.0-alpha.45",
+  "version": "4.0.0-alpha.47",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,11 +18,11 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.570",
+    "@dynamic-labs/sdk-api-core": "0.0.576",
     "tldts": "6.0.16",
-    "@dynamic-labs/assert-package-version": "4.0.0-alpha.45",
-    "@dynamic-labs/logger": "4.0.0-alpha.45",
-    "@dynamic-labs/types": "4.0.0-alpha.45",
+    "@dynamic-labs/assert-package-version": "4.0.0-alpha.47",
+    "@dynamic-labs/logger": "4.0.0-alpha.47",
+    "@dynamic-labs/types": "4.0.0-alpha.47",
     "buffer": "6.0.3",
     "eventemitter3": "5.0.1"
   },

package/src/encryption/convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.cjs

@@ -0,0 +1,31 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Converts a CryptoKey public key to its hexadecimal string representation.
+ *
+ * @param publicKey - The public CryptoKey to convert. Must be extractable.
+ * @returns A Promise that resolves to the hexadecimal string representation of the public key.
+ *
+ * @example
+ * const pair = await createKeyPair(...);
+ * const hexString = await convertPublicKeyCryptoKeyToHex(pair.publicKey);
+ */
+const convertPublicKeyCryptoKeyToHex = (publicKey) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (!publicKey.extractable) {
+        throw new Error('CryptoKey must be extractable to convert to hex.');
+    }
+    // Export the CryptoKey to a raw ArrayBuffer
+    const exportedKey = yield crypto.subtle.exportKey('raw', publicKey);
+    // Convert the ArrayBuffer to a hex string
+    const byteArray = new Uint8Array(exportedKey);
+    return encodeURIComponent(Array.from(byteArray)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join(''));
+});
+
+exports.convertPublicKeyCryptoKeyToHex = convertPublicKeyCryptoKeyToHex;

package/src/encryption/convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a CryptoKey public key to its hexadecimal string representation.
+ *
+ * @param publicKey - The public CryptoKey to convert. Must be extractable.
+ * @returns A Promise that resolves to the hexadecimal string representation of the public key.
+ *
+ * @example
+ * const pair = await createKeyPair(...);
+ * const hexString = await convertPublicKeyCryptoKeyToHex(pair.publicKey);
+ */
+export declare const convertPublicKeyCryptoKeyToHex: (publicKey: CryptoKey) => Promise<string>;

package/src/encryption/convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.js

@@ -0,0 +1,27 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+/**
+ * Converts a CryptoKey public key to its hexadecimal string representation.
+ *
+ * @param publicKey - The public CryptoKey to convert. Must be extractable.
+ * @returns A Promise that resolves to the hexadecimal string representation of the public key.
+ *
+ * @example
+ * const pair = await createKeyPair(...);
+ * const hexString = await convertPublicKeyCryptoKeyToHex(pair.publicKey);
+ */
+const convertPublicKeyCryptoKeyToHex = (publicKey) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!publicKey.extractable) {
+        throw new Error('CryptoKey must be extractable to convert to hex.');
+    }
+    // Export the CryptoKey to a raw ArrayBuffer
+    const exportedKey = yield crypto.subtle.exportKey('raw', publicKey);
+    // Convert the ArrayBuffer to a hex string
+    const byteArray = new Uint8Array(exportedKey);
+    return encodeURIComponent(Array.from(byteArray)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join(''));
+});
+
+export { convertPublicKeyCryptoKeyToHex };

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

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

package/src/encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Converts a hexadecimal string representation of a public key into a CryptoKey object
+ *
+ * @param hex - The hexadecimal string representation of the public key
+ * @returns A Promise that resolves to a CryptoKey object suitable for ECDH operations
+ * @throws Error if the hex string length is invalid or doesn't represent a valid public key
+ */
+const convertPublicKeyHexToCryptoKey = (hex) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    // Validate hex string length (65 bytes = 130 hex characters)
+    if (hex.length !== 130) {
+        throw new Error('Invalid public key length. Expected 130 hex characters.');
+    }
+    // Validate hex string format (should start with '04' for uncompressed point)
+    if (!hex.startsWith('04')) {
+        throw new Error('Invalid public key format. Should start with "04".');
+    }
+    // Convert the hex string to an ArrayBuffer
+    const byteArray = new Uint8Array((_b = (_a = decodeURIComponent(hex)
+        .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
+    return crypto.subtle.importKey('raw', byteArray.buffer, {
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, true, []);
+});
+
+exports.convertPublicKeyHexToCryptoKey = convertPublicKeyHexToCryptoKey;

package/src/encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a hexadecimal string representation of a public key into a CryptoKey object
+ *
+ * @param hex - The hexadecimal string representation of the public key
+ * @returns A Promise that resolves to a CryptoKey object suitable for ECDH operations
+ * @throws Error if the hex string length is invalid or doesn't represent a valid public key
+ */
+export declare const convertPublicKeyHexToCryptoKey: (hex: string) => Promise<CryptoKey>;

package/src/encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.js

@@ -0,0 +1,31 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+/**
+ * Converts a hexadecimal string representation of a public key into a CryptoKey object
+ *
+ * @param hex - The hexadecimal string representation of the public key
+ * @returns A Promise that resolves to a CryptoKey object suitable for ECDH operations
+ * @throws Error if the hex string length is invalid or doesn't represent a valid public key
+ */
+const convertPublicKeyHexToCryptoKey = (hex) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    // Validate hex string length (65 bytes = 130 hex characters)
+    if (hex.length !== 130) {
+        throw new Error('Invalid public key length. Expected 130 hex characters.');
+    }
+    // Validate hex string format (should start with '04' for uncompressed point)
+    if (!hex.startsWith('04')) {
+        throw new Error('Invalid public key format. Should start with "04".');
+    }
+    // Convert the hex string to an ArrayBuffer
+    const byteArray = new Uint8Array((_b = (_a = decodeURIComponent(hex)
+        .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
+    return crypto.subtle.importKey('raw', byteArray.buffer, {
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, true, []);
+});
+
+export { convertPublicKeyHexToCryptoKey };

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

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

package/src/encryption/createKeyPair/createKeyPair.cjs

@@ -0,0 +1,27 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Generates an ECDH key pair for cryptographic operations.
+ * Uses the P-256 curve for key generation, which provides 128-bit security level.
+ *
+ * @returns {Promise<{publicKey: CryptoKey, privateKey: CryptoKey}>} A promise that resolves to an object containing:
+ *   - publicKey: The generated public key
+ *   - privateKey: The generated private key
+ */
+const createKeyPair = () => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const keyPair = yield crypto.subtle.generateKey({
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, true, ['deriveKey', 'deriveBits']);
+    return {
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+    };
+});
+
+exports.createKeyPair = createKeyPair;

package/src/encryption/createKeyPair/createKeyPair.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates an ECDH key pair for cryptographic operations.
+ * Uses the P-256 curve for key generation, which provides 128-bit security level.
+ *
+ * @returns {Promise<{publicKey: CryptoKey, privateKey: CryptoKey}>} A promise that resolves to an object containing:
+ *   - publicKey: The generated public key
+ *   - privateKey: The generated private key
+ */
+export declare const createKeyPair: () => Promise<CryptoKeyPair>;

package/src/encryption/createKeyPair/createKeyPair.js

@@ -0,0 +1,23 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+/**
+ * Generates an ECDH key pair for cryptographic operations.
+ * Uses the P-256 curve for key generation, which provides 128-bit security level.
+ *
+ * @returns {Promise<{publicKey: CryptoKey, privateKey: CryptoKey}>} A promise that resolves to an object containing:
+ *   - publicKey: The generated public key
+ *   - privateKey: The generated private key
+ */
+const createKeyPair = () => __awaiter(void 0, void 0, void 0, function* () {
+    const keyPair = yield crypto.subtle.generateKey({
+        name: 'ECDH',
+        namedCurve: 'P-256',
+    }, true, ['deriveKey', 'deriveBits']);
+    return {
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+    };
+});
+
+export { createKeyPair };

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

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

package/src/encryption/decryptMessage/decryptMessage.cjs

@@ -0,0 +1,48 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+/**
+ * Decrypts an encrypted message using AES-GCM encryption with a shared secret key.
+ *
+ * @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
+ * @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* () {
+    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)));
+    return decoder.decode(new Uint8Array(decryptedData));
+});
+const hexToUint8Array = (hex) => {
+    if (hex.length % 2 !== 0) {
+        throw new Error('Hex string must have an even number of characters');
+    }
+    if (!/^[0-9A-Fa-f]+$/.test(hex)) {
+        throw new Error('Invalid hex characters');
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+    }
+    return bytes;
+};
+const base64ToArrayBuffer = (base64) => {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+};
+
+exports.decryptMessage = decryptMessage;

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

@@ -0,0 +1,9 @@
+/**
+ * Decrypts an encrypted message using AES-GCM encryption with a shared secret key.
+ *
+ * @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
+ * @returns A Promise that resolves to the decrypted message as a string
+ */
+export declare const decryptMessage: (sharedSecret: string, message: string, iv: string) => Promise<string>;

package/src/encryption/decryptMessage/decryptMessage.js

@@ -0,0 +1,44 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+/**
+ * Decrypts an encrypted message using AES-GCM encryption with a shared secret key.
+ *
+ * @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
+ * @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* () {
+    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)));
+    return decoder.decode(new Uint8Array(decryptedData));
+});
+const hexToUint8Array = (hex) => {
+    if (hex.length % 2 !== 0) {
+        throw new Error('Hex string must have an even number of characters');
+    }
+    if (!/^[0-9A-Fa-f]+$/.test(hex)) {
+        throw new Error('Invalid hex characters');
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+    }
+    return bytes;
+};
+const base64ToArrayBuffer = (base64) => {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+};
+
+export { decryptMessage };

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

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

package/src/encryption/deriveSharedSecret/deriveSharedSecret.cjs

@@ -0,0 +1,28 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var convertPublicKeyCryptoKeyToHex = require('../convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.cjs');
+
+/**
+ * Derives a shared secret key using ECDH (Elliptic Curve Diffie-Hellman) key agreement protocol.
+ * The resulting shared secret can be used for AES-GCM encryption/decryption operations.
+ *
+ * @param ownPrivateKey - The private key of the current party (CryptoKey format)
+ * @param peerPublicKey - The public key of the peer party (CryptoKey format)
+ * @returns A Promise that resolves to a hex string representing the derived shared secret
+ *          configured for AES-GCM encryption/decryption operations
+ */
+const deriveSharedSecret = (ownPrivateKey, peerPublicKey) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    return convertPublicKeyCryptoKeyToHex.convertPublicKeyCryptoKeyToHex(yield crypto.subtle.deriveKey({
+        name: 'ECDH',
+        public: peerPublicKey,
+    }, ownPrivateKey, {
+        length: 256,
+        name: 'AES-GCM',
+    }, true, ['encrypt', 'decrypt']));
+});
+
+exports.deriveSharedSecret = deriveSharedSecret;

package/src/encryption/deriveSharedSecret/deriveSharedSecret.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Derives a shared secret key using ECDH (Elliptic Curve Diffie-Hellman) key agreement protocol.
+ * The resulting shared secret can be used for AES-GCM encryption/decryption operations.
+ *
+ * @param ownPrivateKey - The private key of the current party (CryptoKey format)
+ * @param peerPublicKey - The public key of the peer party (CryptoKey format)
+ * @returns A Promise that resolves to a hex string representing the derived shared secret
+ *          configured for AES-GCM encryption/decryption operations
+ */
+export declare const deriveSharedSecret: (ownPrivateKey: CryptoKey, peerPublicKey: CryptoKey) => Promise<string>;

package/src/encryption/deriveSharedSecret/deriveSharedSecret.js

@@ -0,0 +1,24 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { convertPublicKeyCryptoKeyToHex } from '../convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.js';
+
+/**
+ * Derives a shared secret key using ECDH (Elliptic Curve Diffie-Hellman) key agreement protocol.
+ * The resulting shared secret can be used for AES-GCM encryption/decryption operations.
+ *
+ * @param ownPrivateKey - The private key of the current party (CryptoKey format)
+ * @param peerPublicKey - The public key of the peer party (CryptoKey format)
+ * @returns A Promise that resolves to a hex string representing the derived shared secret
+ *          configured for AES-GCM encryption/decryption operations
+ */
+const deriveSharedSecret = (ownPrivateKey, peerPublicKey) => __awaiter(void 0, void 0, void 0, function* () {
+    return convertPublicKeyCryptoKeyToHex(yield crypto.subtle.deriveKey({
+        name: 'ECDH',
+        public: peerPublicKey,
+    }, ownPrivateKey, {
+        length: 256,
+        name: 'AES-GCM',
+    }, true, ['encrypt', 'decrypt']));
+});
+
+export { deriveSharedSecret };

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

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

package/src/encryption/encryptMessage/encryptMessage.cjs

@@ -0,0 +1,42 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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:
+ *   - 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* () {
+    var _a, _b;
+    const encoder = new TextEncoder();
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const data = encoder.encode(message);
+    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);
+    return {
+        encryptedMessage: encodeURIComponent(arrayBufferToBase64(encryptedMessage)),
+        iv: encodeURIComponent(uint8ArrayToHex(iv)),
+    };
+});
+const arrayBufferToBase64 = (buffer) => {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+};
+const uint8ArrayToHex = (arr) => Array.from(arr)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+
+exports.encryptMessage = encryptMessage;

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

@@ -0,0 +1,13 @@
+export type EncryptedMessage = {
+    encryptedMessage: string;
+    iv: string;
+};
+/**
+ * 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:
+ *   - encryptedMessage: Base64 encoded encrypted message
+ *   - iv: Hexadecimal initialization vector used for encryption
+ */
+export declare const encryptMessage: (sharedSecret: string, message: string) => Promise<EncryptedMessage>;

package/src/encryption/encryptMessage/encryptMessage.js

@@ -0,0 +1,38 @@
+'use client'
+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:
+ *   - encryptedMessage: Base64 encoded encrypted message
+ *   - iv: Hexadecimal initialization vector used for encryption
+ */
+const encryptMessage = (sharedSecret, message) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const encoder = new TextEncoder();
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const data = encoder.encode(message);
+    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);
+    return {
+        encryptedMessage: encodeURIComponent(arrayBufferToBase64(encryptedMessage)),
+        iv: encodeURIComponent(uint8ArrayToHex(iv)),
+    };
+});
+const arrayBufferToBase64 = (buffer) => {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+};
+const uint8ArrayToHex = (arr) => Array.from(arr)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+
+export { encryptMessage };

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

@@ -0,0 +1 @@
+export { encryptMessage, type EncryptedMessage } from './encryptMessage';

package/src/encryption/index.d.ts

@@ -0,0 +1,7 @@
+export { createKeyPair } from './createKeyPair';
+export { deriveSharedSecret } from './deriveSharedSecret';
+export { convertPublicKeyCryptoKeyToHex } from './convertPublicKeyCryptoKeyToHex';
+export { convertPublicKeyHexToCryptoKey } from './convertPublicKeyHexToCryptoKey';
+export { decryptMessage } from './decryptMessage';
+export { encryptMessage } from './encryptMessage';
+export { isEncryptedMessage } from './isEncryptedMessage';

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

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

package/src/encryption/isEncryptedMessage/isEncryptedMessage.cjs

@@ -0,0 +1,28 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Type guard to check if a value is an encrypted message
+ * @param value - Value to check
+ * @returns boolean indicating if the value matches the EncryptedMessage format
+ */
+const isEncryptedMessage = (value) => {
+    if (!value ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        value === null ||
+        typeof value === 'string') {
+        return false;
+    }
+    const candidate = value;
+    const keys = Object.keys(candidate);
+    return (keys.length === 2 &&
+        keys.includes('encryptedMessage') &&
+        keys.includes('iv') &&
+        typeof candidate['encryptedMessage'] === 'string' &&
+        typeof candidate['iv'] === 'string');
+};
+
+exports.isEncryptedMessage = isEncryptedMessage;

package/src/encryption/isEncryptedMessage/isEncryptedMessage.d.ts

@@ -0,0 +1,7 @@
+import { EncryptedMessage } from '../encryptMessage';
+/**
+ * Type guard to check if a value is an encrypted message
+ * @param value - Value to check
+ * @returns boolean indicating if the value matches the EncryptedMessage format
+ */
+export declare const isEncryptedMessage: (value: unknown) => value is EncryptedMessage;

package/src/encryption/isEncryptedMessage/isEncryptedMessage.js

@@ -0,0 +1,24 @@
+'use client'
+/**
+ * Type guard to check if a value is an encrypted message
+ * @param value - Value to check
+ * @returns boolean indicating if the value matches the EncryptedMessage format
+ */
+const isEncryptedMessage = (value) => {
+    if (!value ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        value === null ||
+        typeof value === 'string') {
+        return false;
+    }
+    const candidate = value;
+    const keys = Object.keys(candidate);
+    return (keys.length === 2 &&
+        keys.includes('encryptedMessage') &&
+        keys.includes('iv') &&
+        typeof candidate['encryptedMessage'] === 'string' &&
+        typeof candidate['iv'] === 'string');
+};
+
+export { isEncryptedMessage };

package/src/index.cjs

@@ -68,6 +68,13 @@ var sleep = require('./sleep/sleep.cjs');
 var trimEnd = require('./trimEnd/trimEnd.cjs');
 var uniq = require('./uniq/uniq.cjs');
 var wrapMethodWithCallback = require('./wrapMethodWithCallback/wrapMethodWithCallback.cjs');
+var createKeyPair = require('./encryption/createKeyPair/createKeyPair.cjs');
+var deriveSharedSecret = require('./encryption/deriveSharedSecret/deriveSharedSecret.cjs');
+var convertPublicKeyCryptoKeyToHex = require('./encryption/convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.cjs');
+var convertPublicKeyHexToCryptoKey = require('./encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.cjs');
+var decryptMessage = require('./encryption/decryptMessage/decryptMessage.cjs');
+var encryptMessage = require('./encryption/encryptMessage/encryptMessage.cjs');
+var isEncryptedMessage = require('./encryption/isEncryptedMessage/isEncryptedMessage.cjs');
 var cloneObjectWithOverrides = require('./cloneObjectWithOverrides/cloneObjectWithOverrides.cjs');
 var get = require('./get/get.cjs');
 var hexToString = require('./hexToString/hexToString.cjs');
@@ -85,6 +92,7 @@ var StorageService = require('./services/StorageService/StorageService.cjs');
 var createStorageService = require('./services/StorageService/createStorageService/createStorageService.cjs');
 var applyPostfixToStorageService = require('./services/StorageService/applyPostfixToStorageService/applyPostfixToStorageService.cjs');
 var connectWithAppleId = require('./services/Oauth2Service/utils/connectWithAppleId/connectWithAppleId.cjs');
+var solToLamports = require('./solToLamports/solToLamports.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/utils', _package.version);
 
@@ -168,6 +176,13 @@ exports.sleep = sleep.sleep;
 exports.trimEnd = trimEnd.trimEnd;
 exports.uniq = uniq.uniq;
 exports.wrapMethodWithCallback = wrapMethodWithCallback.wrapMethodWithCallback;
+exports.createKeyPair = createKeyPair.createKeyPair;
+exports.deriveSharedSecret = deriveSharedSecret.deriveSharedSecret;
+exports.convertPublicKeyCryptoKeyToHex = convertPublicKeyCryptoKeyToHex.convertPublicKeyCryptoKeyToHex;
+exports.convertPublicKeyHexToCryptoKey = convertPublicKeyHexToCryptoKey.convertPublicKeyHexToCryptoKey;
+exports.decryptMessage = decryptMessage.decryptMessage;
+exports.encryptMessage = encryptMessage.encryptMessage;
+exports.isEncryptedMessage = isEncryptedMessage.isEncryptedMessage;
 exports.cloneObjectWithOverrides = cloneObjectWithOverrides.cloneObjectWithOverrides;
 exports.get = get.get;
 exports.hexToString = hexToString.hexToString;
@@ -185,3 +200,4 @@ exports.StorageService = StorageService.StorageService;
 exports.createStorageService = createStorageService.createStorageService;
 exports.applyPostfixToStorageService = applyPostfixToStorageService.applyPostfixToStorageService;
 exports.connectWithAppleId = connectWithAppleId.connectWithAppleId;
+exports.solToLamports = solToLamports.solToLamports;

package/src/index.d.ts

@@ -25,6 +25,7 @@ export * from './sleep';
 export * from './trimEnd';
 export * from './uniq';
 export * from './wrapMethodWithCallback';
+export * from './encryption';
 export { cloneObjectWithOverrides } from './cloneObjectWithOverrides';
 export { get } from './get';
 export { hexToString } from './hexToString';
@@ -38,3 +39,4 @@ export { FetchService } from './services/FetchService';
 export { Oauth2Service, type GetOauthCodeError, type GetOauthCodeProps, type IOauth2Service, createWindowOauth2Service, } from './services/Oauth2Service';
 export { type IStorageService, type StorageOptions, StorageService, createStorageService, applyPostfixToStorageService, } from './services/StorageService';
 export { connectWithAppleId } from './services/Oauth2Service/utils/connectWithAppleId';
+export { solToLamports } from './solToLamports';

package/src/index.js

@@ -64,6 +64,13 @@ export { sleep } from './sleep/sleep.js';
 export { trimEnd } from './trimEnd/trimEnd.js';
 export { uniq } from './uniq/uniq.js';
 export { wrapMethodWithCallback } from './wrapMethodWithCallback/wrapMethodWithCallback.js';
+export { createKeyPair } from './encryption/createKeyPair/createKeyPair.js';
+export { deriveSharedSecret } from './encryption/deriveSharedSecret/deriveSharedSecret.js';
+export { convertPublicKeyCryptoKeyToHex } from './encryption/convertPublicKeyCryptoKeyToHex/convertPublicKeyCryptoKeyToHex.js';
+export { convertPublicKeyHexToCryptoKey } from './encryption/convertPublicKeyHexToCryptoKey/convertPublicKeyHexToCryptoKey.js';
+export { decryptMessage } from './encryption/decryptMessage/decryptMessage.js';
+export { encryptMessage } from './encryption/encryptMessage/encryptMessage.js';
+export { isEncryptedMessage } from './encryption/isEncryptedMessage/isEncryptedMessage.js';
 export { cloneObjectWithOverrides } from './cloneObjectWithOverrides/cloneObjectWithOverrides.js';
 export { get } from './get/get.js';
 export { hexToString } from './hexToString/hexToString.js';
@@ -81,5 +88,6 @@ export { StorageService } from './services/StorageService/StorageService.js';
 export { createStorageService } from './services/StorageService/createStorageService/createStorageService.js';
 export { applyPostfixToStorageService } from './services/StorageService/applyPostfixToStorageService/applyPostfixToStorageService.js';
 export { connectWithAppleId } from './services/Oauth2Service/utils/connectWithAppleId/connectWithAppleId.js';
+export { solToLamports } from './solToLamports/solToLamports.js';
 
 assertPackageVersion('@dynamic-labs/utils', version);

package/src/solToLamports/index.d.ts

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

package/src/solToLamports/solToLamports.cjs

@@ -0,0 +1,11 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const solToLamports = (solAmount) => {
+    const lamportsPerSol = 1000000000; // 1 SOL = 1,000,000,000 Lamports
+    return solAmount * lamportsPerSol;
+};
+
+exports.solToLamports = solToLamports;

package/src/solToLamports/solToLamports.d.ts

@@ -0,0 +1 @@
+export declare const solToLamports: (solAmount: number) => number;

package/src/solToLamports/solToLamports.js

@@ -0,0 +1,7 @@
+'use client'
+const solToLamports = (solAmount) => {
+    const lamportsPerSol = 1000000000; // 1 SOL = 1,000,000,000 Lamports
+    return solAmount * lamportsPerSol;
+};
+
+export { solToLamports };