@dynamic-labs/utils 4.0.0-alpha.8 → 4.0.0

package/src/{parseEvmNetworks.js → parseNetworks/parseNetworks.js}

@@ -1,5 +1,5 @@
 'use client'
-import { parseChainId } from './parseChainId.js';
+import { parseChainId } from '../parseChainId/parseChainId.js';
 
 const parseEvmNetworks = (networks) => {
     const clone = networks.slice();
@@ -9,5 +9,6 @@ const parseEvmNetworks = (networks) => {
         return network;
     });
 };
+const parseCosmosNetworks = (networks) => parseEvmNetworks(networks);
 
-export { parseEvmNetworks };
+export { parseCosmosNetworks, parseEvmNetworks };

package/src/retryableFn/index.d.ts

@@ -0,0 +1 @@
+export * from './retryableFn';

package/src/{retryableFn.cjs → retryableFn/retryableFn.cjs}

@@ -3,19 +3,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var _tslib = require('../_virtual/_tslib.cjs');
-var sleep = require('./sleep/sleep.cjs');
+var _tslib = require('../../_virtual/_tslib.cjs');
+var sleep = require('../sleep/sleep.cjs');
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {
-    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', retryIntervalMs = 0, logger, } = options;
-    logger === null || logger === void 0 ? void 0 : logger.debug('Configured retryableFn with options: ', {
-        currentRetry,
-        fallbackValue,
-        maxRetries,
-        retryStrategy,
-        timeoutMs,
-    });
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', retryIntervalMs = 0, } = options;
     const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
             reject(new Error('Timeout'));
@@ -26,9 +19,7 @@ const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args
         return result;
     }
     catch (err) {
-        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn caught error: ', err);
         if (currentRetry >= maxRetries) {
-            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning/throwing fallback value', err, fallbackValue);
             if (fallbackValue instanceof Error) {
                 throw fallbackValue;
             }
@@ -41,18 +32,13 @@ const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args
         const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
             (retryStrategy === 'timeout-only' && isTimeout) ||
             (retryStrategy === 'rejection-only' && !isTimeout);
-        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn shouldRetry: ', shouldRetry);
         if (!shouldRetry) {
             if (fallbackValue instanceof Error) {
-                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn throwing fallbackValue error: ', fallbackValue);
                 throw err;
             }
             else if (fallbackValue === FALLBACK_UNDEFINED) {
-                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning undefined');
                 return undefined;
             }
-            logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning fallbackValue: ', fallbackValue);
-            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning fallback value', err);
             return fallbackValue;
         }
         if (retryIntervalMs)
@@ -60,7 +46,6 @@ const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args
         return retryableFn(fn, {
             currentRetry: currentRetry + 1,
             fallbackValue,
-            logger,
             maxRetries,
             retryIntervalMs,
             retryStrategy,

package/src/{retryableFn.d.ts → retryableFn/retryableFn.d.ts}

@@ -1,4 +1,3 @@
-import { Logger } from '@dynamic-labs/logger';
 export declare const FALLBACK_UNDEFINED = "FALLBACK_UNDEFINED";
 export type RetryableFnOptions<T> = {
     /** Maximum number of retry attempts before returning fallbackValue */
@@ -11,8 +10,6 @@ export type RetryableFnOptions<T> = {
     fallbackValue?: T | Error | typeof FALLBACK_UNDEFINED;
     /** Configure whether the fn should be retried only on timeout, only on rejection, or both */
     retryStrategy?: 'timeout-only' | 'rejection-only' | 'timeout-and-rejection';
-    /** Set the logger to be used */
-    logger?: Logger | typeof console;
     /** Ms to wait before a retry */
     retryIntervalMs?: number;
 };

package/src/{retryableFn.js → retryableFn/retryableFn.js}

@@ -1,17 +1,10 @@
 'use client'
-import { __awaiter } from '../_virtual/_tslib.js';
-import { sleep } from './sleep/sleep.js';
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { sleep } from '../sleep/sleep.js';
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {
-    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', retryIntervalMs = 0, logger, } = options;
-    logger === null || logger === void 0 ? void 0 : logger.debug('Configured retryableFn with options: ', {
-        currentRetry,
-        fallbackValue,
-        maxRetries,
-        retryStrategy,
-        timeoutMs,
-    });
+    const { maxRetries = 3, currentRetry = 0, timeoutMs = 100, fallbackValue = new Error('Max retries reached'), retryStrategy = 'timeout-only', retryIntervalMs = 0, } = options;
     const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => {
             reject(new Error('Timeout'));
@@ -22,9 +15,7 @@ const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], vo
         return result;
     }
     catch (err) {
-        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn caught error: ', err);
         if (currentRetry >= maxRetries) {
-            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning/throwing fallback value', err, fallbackValue);
             if (fallbackValue instanceof Error) {
                 throw fallbackValue;
             }
@@ -37,18 +28,13 @@ const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], vo
         const shouldRetry = retryStrategy === 'timeout-and-rejection' ||
             (retryStrategy === 'timeout-only' && isTimeout) ||
             (retryStrategy === 'rejection-only' && !isTimeout);
-        logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn shouldRetry: ', shouldRetry);
         if (!shouldRetry) {
             if (fallbackValue instanceof Error) {
-                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn throwing fallbackValue error: ', fallbackValue);
                 throw err;
             }
             else if (fallbackValue === FALLBACK_UNDEFINED) {
-                logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning undefined');
                 return undefined;
             }
-            logger === null || logger === void 0 ? void 0 : logger.debug('retryableFn returning fallbackValue: ', fallbackValue);
-            logger === null || logger === void 0 ? void 0 : logger.error('Error while retrying function, returning fallback value', err);
             return fallbackValue;
         }
         if (retryIntervalMs)
@@ -56,7 +42,6 @@ const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], vo
         return retryableFn(fn, {
             currentRetry: currentRetry + 1,
             fallbackValue,
-            logger,
             maxRetries,
             retryIntervalMs,
             retryStrategy,

package/src/sanitizeName/index.d.ts

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

package/src/sanitizeName/sanitizeName.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const sanitizeName = (name) => name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+
+exports.sanitizeName = sanitizeName;

package/src/sanitizeName/sanitizeName.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeName: (name: string) => string;

package/src/sanitizeName/sanitizeName.js

@@ -0,0 +1,4 @@
+'use client'
+const sanitizeName = (name) => name.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+
+export { sanitizeName };

package/src/services/Oauth2Service/Oauth2Service.d.ts

@@ -15,7 +15,6 @@ export type GetOauthCodeProps = {
      * The preferred strategy to use for the OAuth2 flow.
      */
     strategy: 'popup' | 'redirect';
-    sessionTimeout: number;
     /**
      * Overrides the default redirectUrl coming from the DynamicContextProvider
      */

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.cjs

@@ -7,7 +7,7 @@ var _tslib = require('../../../../_virtual/_tslib.cjs');
 var types = require('@dynamic-labs/types');
 var logger = require('../../../logger/logger.cjs');
 var connectWithAppleId = require('../utils/connectWithAppleId/connectWithAppleId.cjs');
-var isMobile = require('../../../isMobile.cjs');
+var isMobile = require('../../../isMobile/isMobile.cjs');
 
 let authWindowInterval;
 const createWindowOauth2Service = () => ({
@@ -46,6 +46,14 @@ const createWindowOauth2Service = () => ({
         clearInterval(authWindowInterval);
         const providersWaitingOauthMessage = {};
         const authWindow = window.open('', '_blank', 'width=500,height=600');
+        if (authWindow === null || typeof authWindow === 'undefined') {
+            // Pop-ups are blocked
+            typedReject({
+                code: types.SocialOAuthErrorCode.OAUTH_WINDOW_BLOCKED,
+                message: 'Please allow popups and try again.',
+            });
+            return;
+        }
         const clearListeners = () => {
             window.removeEventListener('message', handleWindowMessage);
             providersWaitingOauthMessage[provider] = false;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.js

@@ -3,7 +3,7 @@ import { __awaiter } from '../../../../_virtual/_tslib.js';
 import { ProviderEnum, SocialOAuthErrorCode } from '@dynamic-labs/types';
 import { logger } from '../../../logger/logger.js';
 import { connectWithAppleId } from '../utils/connectWithAppleId/connectWithAppleId.js';
-import { isSafariBrowser, isIOS } from '../../../isMobile.js';
+import { isSafariBrowser, isIOS } from '../../../isMobile/isMobile.js';
 
 let authWindowInterval;
 const createWindowOauth2Service = () => ({
@@ -42,6 +42,14 @@ const createWindowOauth2Service = () => ({
         clearInterval(authWindowInterval);
         const providersWaitingOauthMessage = {};
         const authWindow = window.open('', '_blank', 'width=500,height=600');
+        if (authWindow === null || typeof authWindow === 'undefined') {
+            // Pop-ups are blocked
+            typedReject({
+                code: SocialOAuthErrorCode.OAUTH_WINDOW_BLOCKED,
+                message: 'Please allow popups and try again.',
+            });
+            return;
+        }
         const clearListeners = () => {
             window.removeEventListener('message', handleWindowMessage);
             providersWaitingOauthMessage[provider] = false;

package/src/services/StorageService/StorageService.d.ts

@@ -20,7 +20,7 @@ export declare class StorageService {
     static registerSourceStorage(source: StorageSource, implementation: IStorageService): void;
     static getSourceStorage(source: StorageSource): IStorageService | undefined;
     static resolveStorage(options?: StorageOptions): IStorageService;
-    static getItem<T = string>(key: string, options?: StorageOptions): T | undefined;
+    static getItem<T = string>(key: string, options?: StorageOptions): T | null;
     static setItem<T>(key: string, value: T, options?: StorageOptions): void;
     static removeItem(key: string, options?: StorageOptions): void;
     static getKeys(options?: StorageOptions): string[];

package/src/services/StorageService/applyPostfixToStorageService/applyPostfixToStorageService.cjs

@@ -0,0 +1,11 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const applyPostfixToStorageService = ({ storage, postfix, }) => {
+    const getKeyWithPostfix = (key) => postfix ? `${key}_${postfix}` : key;
+    return Object.assign(Object.assign({}, storage), { getItem: (key) => storage.getItem(getKeyWithPostfix(key)), removeItem: (key) => storage.removeItem(getKeyWithPostfix(key)), setItem: (key, data) => storage.setItem(getKeyWithPostfix(key), data) });
+};
+
+exports.applyPostfixToStorageService = applyPostfixToStorageService;

package/src/services/StorageService/applyPostfixToStorageService/applyPostfixToStorageService.d.ts

@@ -0,0 +1,7 @@
+import { IStorageService } from '../types';
+type ApplyPostfixToStorageServiceProps<T extends IStorageService> = {
+    storage: T;
+    postfix: string | undefined;
+};
+export declare const applyPostfixToStorageService: <T extends IStorageService>({ storage, postfix, }: ApplyPostfixToStorageServiceProps<T>) => T;
+export {};

package/src/services/StorageService/applyPostfixToStorageService/applyPostfixToStorageService.js

@@ -0,0 +1,7 @@
+'use client'
+const applyPostfixToStorageService = ({ storage, postfix, }) => {
+    const getKeyWithPostfix = (key) => postfix ? `${key}_${postfix}` : key;
+    return Object.assign(Object.assign({}, storage), { getItem: (key) => storage.getItem(getKeyWithPostfix(key)), removeItem: (key) => storage.removeItem(getKeyWithPostfix(key)), setItem: (key, data) => storage.setItem(getKeyWithPostfix(key), data) });
+};
+
+export { applyPostfixToStorageService };

package/src/services/StorageService/applyPostfixToStorageService/index.d.ts

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

package/src/services/StorageService/createStorageService/createStorageService.cjs

@@ -6,13 +6,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var logger = require('../../../logger/logger.cjs');
 var StorageService = require('../StorageService.cjs');
 
-const createStorageService = ({ postfix, storage, }) => {
-    const getKey = (key) => (postfix ? `${key}_${postfix}` : key);
+const createStorageService = ({ storage, }) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const packValue = (value) => JSON.stringify(value);
     const unpackValue = (value) => JSON.parse(value);
     const getItem = (key) => {
-        const value = storage.getItem(getKey(key));
+        const value = storage.getItem(key);
         if (!value) {
             return undefined;
         }
@@ -29,10 +28,10 @@ const createStorageService = ({ postfix, storage, }) => {
         return undefined;
     };
     const setItem = (key, value) => {
-        storage.setItem(getKey(key), packValue(value));
+        storage.setItem(key, packValue(value));
     };
     const removeItem = (key) => {
-        storage.removeItem(getKey(key));
+        storage.removeItem(key);
     };
     const getKeys = () => Object.keys(storage);
     return {

package/src/services/StorageService/createStorageService/createStorageService.d.ts

@@ -1,7 +1,6 @@
 import { IStorageService } from '../types';
 type CreateStorageServiceProps = {
-    postfix?: string;
     storage: Storage;
 };
-export declare const createStorageService: ({ postfix, storage, }: CreateStorageServiceProps) => IStorageService;
+export declare const createStorageService: ({ storage, }: CreateStorageServiceProps) => IStorageService;
 export {};

package/src/services/StorageService/createStorageService/createStorageService.js

@@ -2,13 +2,12 @@
 import { logger } from '../../../logger/logger.js';
 import { StorageService } from '../StorageService.js';
 
-const createStorageService = ({ postfix, storage, }) => {
-    const getKey = (key) => (postfix ? `${key}_${postfix}` : key);
+const createStorageService = ({ storage, }) => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const packValue = (value) => JSON.stringify(value);
     const unpackValue = (value) => JSON.parse(value);
     const getItem = (key) => {
-        const value = storage.getItem(getKey(key));
+        const value = storage.getItem(key);
         if (!value) {
             return undefined;
         }
@@ -25,10 +24,10 @@ const createStorageService = ({ postfix, storage, }) => {
         return undefined;
     };
     const setItem = (key, value) => {
-        storage.setItem(getKey(key), packValue(value));
+        storage.setItem(key, packValue(value));
     };
     const removeItem = (key) => {
-        storage.removeItem(getKey(key));
+        storage.removeItem(key);
     };
     const getKeys = () => Object.keys(storage);
     return {

package/src/services/StorageService/index.d.ts

@@ -1,3 +1,4 @@
 export { StorageService, type StorageOptions } from './StorageService';
 export { createStorageService } from './createStorageService';
 export type { IStorageService } from './types';
+export { applyPostfixToStorageService } from './applyPostfixToStorageService';

package/src/services/StorageService/types.d.ts

@@ -1,5 +1,5 @@
 export type IStorageService = {
-    getItem: <T = string>(key: string) => T | undefined;
+    getItem: <T = string>(key: string) => T | null;
     setItem: <T>(key: string, value: T) => void;
     removeItem: (key: string) => void;
     getKeys: () => string[];

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 };

package/src/uint8ArrayToBase64/index.d.ts

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

package/src/uint8ArrayToBase64/uint8ArrayToBase64.cjs

@@ -0,0 +1,32 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Converts a Uint8Array to a base64 encoded string
+ * @param buf - The Uint8Array to convert
+ * @returns The base64 encoded string representation of the input buffer
+ * @example
+ * ```ts
+ * const originalData = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+ * const base64 = uint8ArrayToBase64(originalData); // "SGVsbG8="
+ * const restored = uint8ArrayFromBase64(base64); // Uint8Array [72, 101, 108, 108, 111]
+ * ```
+ */
+const uint8ArrayToBase64 = (buf) => Buffer.from(buf).toString('base64');
+/**
+ * Converts a base64 encoded string back to a Uint8Array
+ * @param base64 - The base64 encoded string to convert
+ * @returns The Uint8Array representation of the input base64 string
+ * @example
+ * ```ts
+ * const base64String = "SGVsbG8="; // "Hello" encoded in base64
+ * const uint8Array = uint8ArrayFromBase64(base64String); // Uint8Array [72, 101, 108, 108, 111]
+ * const backToBase64 = uint8ArrayToBase64(uint8Array); // "SGVsbG8="
+ * ```
+ */
+const uint8ArrayFromBase64 = (base64) => Uint8Array.from(Buffer.from(base64, 'base64'));
+
+exports.uint8ArrayFromBase64 = uint8ArrayFromBase64;
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;

package/src/uint8ArrayToBase64/uint8ArrayToBase64.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Converts a Uint8Array to a base64 encoded string
+ * @param buf - The Uint8Array to convert
+ * @returns The base64 encoded string representation of the input buffer
+ * @example
+ * ```ts
+ * const originalData = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+ * const base64 = uint8ArrayToBase64(originalData); // "SGVsbG8="
+ * const restored = uint8ArrayFromBase64(base64); // Uint8Array [72, 101, 108, 108, 111]
+ * ```
+ */
+export declare const uint8ArrayToBase64: (buf: Uint8Array) => string;
+/**
+ * Converts a base64 encoded string back to a Uint8Array
+ * @param base64 - The base64 encoded string to convert
+ * @returns The Uint8Array representation of the input base64 string
+ * @example
+ * ```ts
+ * const base64String = "SGVsbG8="; // "Hello" encoded in base64
+ * const uint8Array = uint8ArrayFromBase64(base64String); // Uint8Array [72, 101, 108, 108, 111]
+ * const backToBase64 = uint8ArrayToBase64(uint8Array); // "SGVsbG8="
+ * ```
+ */
+export declare const uint8ArrayFromBase64: (base64: string) => Uint8Array;

package/src/uint8ArrayToBase64/uint8ArrayToBase64.js

@@ -0,0 +1,27 @@
+'use client'
+/**
+ * Converts a Uint8Array to a base64 encoded string
+ * @param buf - The Uint8Array to convert
+ * @returns The base64 encoded string representation of the input buffer
+ * @example
+ * ```ts
+ * const originalData = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+ * const base64 = uint8ArrayToBase64(originalData); // "SGVsbG8="
+ * const restored = uint8ArrayFromBase64(base64); // Uint8Array [72, 101, 108, 108, 111]
+ * ```
+ */
+const uint8ArrayToBase64 = (buf) => Buffer.from(buf).toString('base64');
+/**
+ * Converts a base64 encoded string back to a Uint8Array
+ * @param base64 - The base64 encoded string to convert
+ * @returns The Uint8Array representation of the input base64 string
+ * @example
+ * ```ts
+ * const base64String = "SGVsbG8="; // "Hello" encoded in base64
+ * const uint8Array = uint8ArrayFromBase64(base64String); // Uint8Array [72, 101, 108, 108, 111]
+ * const backToBase64 = uint8ArrayToBase64(uint8Array); // "SGVsbG8="
+ * ```
+ */
+const uint8ArrayFromBase64 = (base64) => Uint8Array.from(Buffer.from(base64, 'base64'));
+
+export { uint8ArrayFromBase64, uint8ArrayToBase64 };

package/src/parseEvmNetworks.d.ts

@@ -1,2 +0,0 @@
-import { EvmNetwork, GenericNetwork } from '@dynamic-labs/types';
-export declare const parseEvmNetworks: (networks: GenericNetwork[]) => EvmNetwork[];