@dynamic-labs/embedded-wallet-solana 0.0.0-exp20240809.0 → 0.0.0-exp20240827.1

package/src/lib/utils/api/api.js

@@ -0,0 +1,32 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { VersionedTransaction } from '@solana/web3.js';
+import { sdkApi } from './utils/SdkApi.js';
+
+const serializeTransaction = (transaction) => {
+    if (transaction instanceof VersionedTransaction) {
+        return Buffer.from(transaction.serialize()).toString('base64');
+    }
+    else {
+        return Buffer.from(transaction.serialize({ verifySignatures: false })).toString('base64');
+    }
+};
+const deserializeTransaction = (serializedTransaction) => {
+    const transactionBuffer = Buffer.from(serializedTransaction, 'base64');
+    return VersionedTransaction.deserialize(transactionBuffer);
+};
+const optimizeSolanaTransaction = (environmentId, transaction, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const serializedTransaction = serializeTransaction(transaction);
+    const request = {
+        environmentId,
+        solanaTransactionOptimizationRequest: {
+            address,
+            transaction: serializedTransaction,
+        },
+    };
+    const response = yield sdkApi().optimizeTransaction(request);
+    const optimizedTransaction = deserializeTransaction(response.transaction);
+    return optimizedTransaction;
+});
+
+export { deserializeTransaction, optimizeSolanaTransaction, serializeTransaction };

package/src/lib/utils/api/events/DynamicEvents.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+const dynamicEvents = new EventEmitter__default["default"]();
+
+exports.dynamicEvents = dynamicEvents;

package/src/lib/utils/api/events/DynamicEvents.d.ts

@@ -0,0 +1,6 @@
+import EventEmitter from 'eventemitter3';
+import { AuthEvents } from './auth';
+/** Maps internal event names to their listeners */
+export type DynamicEvents = AuthEvents;
+export declare const dynamicEvents: EventEmitter<AuthEvents, any>;
+export type DynamicEventEmitter = typeof dynamicEvents;

package/src/lib/utils/api/events/DynamicEvents.js

@@ -0,0 +1,6 @@
+'use client'
+import EventEmitter from 'eventemitter3';
+
+const dynamicEvents = new EventEmitter();
+
+export { dynamicEvents };

package/src/lib/utils/api/events/auth.d.ts

@@ -0,0 +1,51 @@
+import { AuthMethod, AuthOptions } from '@dynamic-labs/types';
+/**
+ * Maps auth methods to what property will be displayed under the "option" property of the event.
+ *
+ * Users will be able to access this data through the AuthOptions[K] type injection as well,
+ * but with the "option" property they will also have a standard way to access the auth method target.
+ */
+type AuthEventPayloadOptionMap = {
+    wallet: AuthOptions['wallet']['connectorName'];
+    sms: AuthOptions['sms']['phone'];
+    email: AuthOptions['email']['email'];
+    social: AuthOptions['social']['provider'];
+    externalAuth: AuthOptions['externalAuth']['externalUserId'];
+};
+/** Payload of auth events that provide insight into which auth method was selected */
+export type AuthEventPayload = {
+    [K in AuthMethod]: {
+        type: K;
+        option: AuthEventPayloadOptionMap[K];
+    } & AuthOptions[K];
+}[AuthMethod];
+export type AuthEvents = {
+    /**
+     * Informs an auth attempt failed.
+     * In general triggered when an error occurs or when user cancels out.
+     * For email/sms, specifically happens when users cancels the OTP verification.
+     */
+    authFailure: (method: AuthEventPayload, 
+    /** Will be 'user-cancelled' when cancelled, or the error when there is an error */
+    reason: 'user-cancelled' | {
+        error: unknown;
+    }) => void;
+    /** Informs an auth attempt initialized, and provides insight into which auth option it is */
+    authInit: (method: AuthEventPayload) => void;
+    logout: () => void;
+    /** This event is used to trigger logout to be called, DO NOT listen to it. Listen to "logout" instead */
+    triggerLogout: () => void;
+    /**
+     * Emitted when the user succesfully completes an MFA challenge
+     */
+    mfaCompletionSuccess: (args: {
+        mfaToken?: string;
+    }) => void;
+    /**
+     * Emitted when there is an error verifiyng the MFA challenge
+     */
+    mfaCompletionFailure: (args: {
+        error: unknown;
+    }) => void;
+};
+export {};

package/src/lib/utils/api/utils/ApiEndpoint.cjs

@@ -0,0 +1,41 @@
+'use client'
+'use strict';
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+/* eslint-disable no-underscore-dangle */
+class ApiEndpoint {
+}
+ApiEndpoint.getBaseUrl = () => {
+    if (!ApiEndpoint.__defined__) {
+        throw new Error('ApiEndpoint Base URL has not been initialized');
+    }
+    return ApiEndpoint.__baseUrl__;
+};
+ApiEndpoint.setBaseUrl = (baseUrlInput) => {
+    if (!ApiEndpoint.__defined__) {
+        if (!baseUrlInput) {
+            /**
+             * If the baseUrl is not provided, use the default baseUrl from the sdk-api package
+             */
+            ApiEndpoint.__baseUrl__ = new sdkApiCore.Configuration().basePath;
+        }
+        else {
+            ApiEndpoint.__baseUrl__ = baseUrlInput;
+        }
+        ApiEndpoint.__defined__ = true;
+    }
+    else if (!baseUrlInput && ApiEndpoint.__defined__) {
+        /**
+         * If for some reason (usually in local development), the setBaseUrl is called multiple times with undefined
+         * And we already have it defined, let's just assume it's a no-op
+         */
+        return;
+    }
+    else if (ApiEndpoint.__baseUrl__ !== baseUrlInput) {
+        throw new Error(`ApiEndpoint baseUrl is already set to ${ApiEndpoint.__baseUrl__}, cannot change it to ${baseUrlInput}`);
+    }
+    Object.freeze(ApiEndpoint);
+};
+
+module.exports = ApiEndpoint;

package/src/lib/utils/api/utils/ApiEndpoint.d.ts

@@ -0,0 +1,7 @@
+declare class ApiEndpoint {
+    private static __baseUrl__;
+    private static __defined__;
+    static getBaseUrl: () => string | undefined;
+    static setBaseUrl: (baseUrlInput?: string) => void;
+}
+export default ApiEndpoint;

package/src/lib/utils/api/utils/ApiEndpoint.js

@@ -0,0 +1,39 @@
+'use client'
+import { Configuration } from '@dynamic-labs/sdk-api-core';
+
+/* eslint-disable no-underscore-dangle */
+class ApiEndpoint {
+}
+ApiEndpoint.getBaseUrl = () => {
+    if (!ApiEndpoint.__defined__) {
+        throw new Error('ApiEndpoint Base URL has not been initialized');
+    }
+    return ApiEndpoint.__baseUrl__;
+};
+ApiEndpoint.setBaseUrl = (baseUrlInput) => {
+    if (!ApiEndpoint.__defined__) {
+        if (!baseUrlInput) {
+            /**
+             * If the baseUrl is not provided, use the default baseUrl from the sdk-api package
+             */
+            ApiEndpoint.__baseUrl__ = new Configuration().basePath;
+        }
+        else {
+            ApiEndpoint.__baseUrl__ = baseUrlInput;
+        }
+        ApiEndpoint.__defined__ = true;
+    }
+    else if (!baseUrlInput && ApiEndpoint.__defined__) {
+        /**
+         * If for some reason (usually in local development), the setBaseUrl is called multiple times with undefined
+         * And we already have it defined, let's just assume it's a no-op
+         */
+        return;
+    }
+    else if (ApiEndpoint.__baseUrl__ !== baseUrlInput) {
+        throw new Error(`ApiEndpoint baseUrl is already set to ${ApiEndpoint.__baseUrl__}, cannot change it to ${baseUrlInput}`);
+    }
+    Object.freeze(ApiEndpoint);
+};
+
+export { ApiEndpoint as default };

package/src/lib/utils/api/utils/LocalStorage.cjs

@@ -0,0 +1,81 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicEvents = require('../events/DynamicEvents.cjs');
+var helpers = require('./helpers.cjs');
+
+const AUTH_TOKEN = 'dynamic_authentication_token';
+class LocalStorage {
+    static getDynamicLSKey(key) {
+        return `${key}${LocalStorage.getSuffix()}`;
+    }
+    static validateRequest(key, fromAuxiliaryAuthFunctions) {
+        if (key === AUTH_TOKEN && !fromAuxiliaryAuthFunctions) {
+            throw new Error('You cannot access AUTH_TOKEN through localStorage. Use getAuthToken/ storeAuthToken helper functions instead');
+        }
+    }
+    static setSuffix(localStorageSuffix) {
+        if (!LocalStorage.__suffix__) {
+            const suffix = (localStorageSuffix && `_${localStorageSuffix}`) || '';
+            LocalStorage.__suffix__ = suffix;
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS(key, getAuth = false) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        LocalStorage.validateRequest(key, getAuth);
+        const value = window.localStorage.getItem(LocalStorage.getDynamicLSKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            helpers.logger.debug(`Error while parsing ${key} from local storage`, { value });
+            LocalStorage.removeFromLS(key);
+            DynamicEvents.dynamicEvents.emit('triggerLogout');
+        }
+        return undefined;
+    }
+    static removeFromLS(key) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        return window.localStorage.removeItem(LocalStorage.getDynamicLSKey(key));
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS(key, value, storeAuth = false) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        LocalStorage.validateRequest(key, storeAuth);
+        window.localStorage.setItem(LocalStorage.getDynamicLSKey(key), JSON.stringify(value));
+    }
+    static getKeys() {
+        if (typeof window === 'undefined') {
+            return [];
+        }
+        return Object.keys(window.localStorage);
+    }
+}
+LocalStorage.getSuffix = () => LocalStorage.__suffix__ || '';
+
+exports.AUTH_TOKEN = AUTH_TOKEN;
+exports.LocalStorage = LocalStorage;
+exports["default"] = LocalStorage;

package/src/lib/utils/api/utils/LocalStorage.d.ts

@@ -0,0 +1,26 @@
+export declare const AUTH_TOKEN = "dynamic_authentication_token";
+export declare class LocalStorage {
+    private static __suffix__;
+    static getSuffix: () => string;
+    private static getDynamicLSKey;
+    private static validateRequest;
+    static setSuffix(localStorageSuffix?: string): void;
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS<T = any>(key: string, getAuth?: boolean): T | undefined;
+    static removeFromLS(key: string): void;
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS<T = any>(key: string, value: T, storeAuth?: boolean): void;
+    static getKeys(): string[];
+}
+export default LocalStorage;

package/src/lib/utils/api/utils/LocalStorage.js

@@ -0,0 +1,75 @@
+'use client'
+import { dynamicEvents } from '../events/DynamicEvents.js';
+import { logger } from './helpers.js';
+
+const AUTH_TOKEN = 'dynamic_authentication_token';
+class LocalStorage {
+    static getDynamicLSKey(key) {
+        return `${key}${LocalStorage.getSuffix()}`;
+    }
+    static validateRequest(key, fromAuxiliaryAuthFunctions) {
+        if (key === AUTH_TOKEN && !fromAuxiliaryAuthFunctions) {
+            throw new Error('You cannot access AUTH_TOKEN through localStorage. Use getAuthToken/ storeAuthToken helper functions instead');
+        }
+    }
+    static setSuffix(localStorageSuffix) {
+        if (!LocalStorage.__suffix__) {
+            const suffix = (localStorageSuffix && `_${localStorageSuffix}`) || '';
+            LocalStorage.__suffix__ = suffix;
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS(key, getAuth = false) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        LocalStorage.validateRequest(key, getAuth);
+        const value = window.localStorage.getItem(LocalStorage.getDynamicLSKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            logger.debug(`Error while parsing ${key} from local storage`, { value });
+            LocalStorage.removeFromLS(key);
+            dynamicEvents.emit('triggerLogout');
+        }
+        return undefined;
+    }
+    static removeFromLS(key) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        return window.localStorage.removeItem(LocalStorage.getDynamicLSKey(key));
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS(key, value, storeAuth = false) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        LocalStorage.validateRequest(key, storeAuth);
+        window.localStorage.setItem(LocalStorage.getDynamicLSKey(key), JSON.stringify(value));
+    }
+    static getKeys() {
+        if (typeof window === 'undefined') {
+            return [];
+        }
+        return Object.keys(window.localStorage);
+    }
+}
+LocalStorage.getSuffix = () => LocalStorage.__suffix__ || '';
+
+export { AUTH_TOKEN, LocalStorage, LocalStorage as default };

package/src/lib/utils/api/utils/SdkApi.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var utils = require('@dynamic-labs/utils');
+var helpers = require('./helpers.cjs');
+var ApiEndpoint = require('./ApiEndpoint.cjs');
+var version = require('./version.cjs');
+
+const sdkApi = () => {
+    const baseUrl = process.env.API_BASE_URL ||
+        process.env.NX_API_BASE_URL ||
+        'https://app.dynamic.xyz/api/v0';
+    ApiEndpoint.setBaseUrl(baseUrl);
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    const minJwt = helpers.getMinAuthToken();
+    if (minJwt) {
+        settings.headers.Authorization = `Bearer ${minJwt}`;
+    }
+    const credentials = helpers.isCookieEnabled()
+        ? 'include'
+        : undefined;
+    settings.headers['x-dyn-version'] = `WalletKit/${version.VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${version.API_VERSION}`;
+    return new sdkApiCore.SDKApi(new sdkApiCore.Configuration(Object.assign(Object.assign({}, settings), { credentials, fetchApi: utils.FetchService.fetch })));
+};
+
+exports.sdkApi = sdkApi;

package/src/lib/utils/api/utils/SdkApi.d.ts

@@ -0,0 +1,2 @@
+import { SDKApi } from '@dynamic-labs/sdk-api-core';
+export declare const sdkApi: () => SDKApi;

package/src/lib/utils/api/utils/SdkApi.js

@@ -0,0 +1,31 @@
+'use client'
+import { SDKApi, Configuration } from '@dynamic-labs/sdk-api-core';
+import { FetchService } from '@dynamic-labs/utils';
+import { getMinAuthToken, isCookieEnabled } from './helpers.js';
+import ApiEndpoint from './ApiEndpoint.js';
+import { VERSION, API_VERSION } from './version.js';
+
+const sdkApi = () => {
+    const baseUrl = process.env.API_BASE_URL ||
+        process.env.NX_API_BASE_URL ||
+        'https://app.dynamic.xyz/api/v0';
+    ApiEndpoint.setBaseUrl(baseUrl);
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    const minJwt = getMinAuthToken();
+    if (minJwt) {
+        settings.headers.Authorization = `Bearer ${minJwt}`;
+    }
+    const credentials = isCookieEnabled()
+        ? 'include'
+        : undefined;
+    settings.headers['x-dyn-version'] = `WalletKit/${VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${API_VERSION}`;
+    return new SDKApi(new Configuration(Object.assign(Object.assign({}, settings), { credentials, fetchApi: FetchService.fetch })));
+};
+
+export { sdkApi };

package/src/lib/utils/api/utils/helpers.cjs

@@ -0,0 +1,88 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger$1 = require('@dynamic-labs/logger');
+var LocalStorage = require('./LocalStorage.cjs');
+
+const logger = new logger$1.Logger('DynamicSDK');
+const AUTH_MIN_TOKEN = 'dynamic_min_authentication_token';
+const AUTH_MIN_TOKEN_DEMO = 'dynamic_min_authentication_token_demo';
+const isCookieEnabled = () => {
+    var _a, _b, _c, _d;
+    let securitySettings = (_a = LocalStorage.LocalStorage.getFromLS('dynamic_store')) !== null && _a !== void 0 ? _a : LocalStorage.LocalStorage.getFromLS('dynamic_store_demo');
+    securitySettings = (_b = securitySettings === null || securitySettings === void 0 ? void 0 : securitySettings.settings) === null || _b === void 0 ? void 0 : _b.security;
+    if (!securitySettings)
+        return false;
+    // client uses Dynamic cookies
+    const dynamicCookiesEnabled = (((_c = securitySettings.auth) === null || _c === void 0 ? void 0 : _c.storage) || []).includes(sdkApiCore.AuthStorageEnum.Cookie);
+    // BYO JWT client puts their non-Dynamic JWT in a cookie
+    const byoJwtCookieEnabled = Boolean((_d = securitySettings.externalAuth) === null || _d === void 0 ? void 0 : _d.cookieName);
+    // should return true for both of these scenarios
+    // because we also need to do `credentials: true` in api.ts when
+    // a byo jwt client sets their named cookie for their jwt and
+    // needs to send it to our backend
+    return dynamicCookiesEnabled || byoJwtCookieEnabled;
+};
+const parseToken = (token) => {
+    var _a;
+    if (!token)
+        return undefined;
+    const base64 = (_a = token.split('.')[1]) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = base64 &&
+        decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+            .join(''));
+    return JSON.parse(jsonPayload);
+};
+const decodeMinJwt = (token) => {
+    try {
+        const json = parseToken(token);
+        if (!json)
+            return undefined;
+        return sdkApiCore.MinifiedDynamicJwtFromJSON(json);
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+};
+const getMinAuthToken = () => {
+    var _a;
+    if (typeof window === 'undefined')
+        return undefined;
+    const token = (_a = LocalStorage.LocalStorage.getFromLS(AUTH_MIN_TOKEN, true)) !== null && _a !== void 0 ? _a : LocalStorage.LocalStorage.getFromLS(AUTH_MIN_TOKEN_DEMO, true);
+    if (!token || isMinAuthTokenExpired(token))
+        return undefined;
+    return token;
+};
+const isMinAuthTokenExpired = (token) => {
+    const decoded = decodeMinJwt(token);
+    return isTokenExpired(decoded);
+};
+const isTokenExpired = (decoded) => {
+    if (!decoded) {
+        return true;
+    }
+    if (!decoded.exp) {
+        return true;
+    }
+    const expirationTime = new Date(decoded.exp * 1000).getTime();
+    const currentTime = new Date().getTime();
+    if (currentTime >= expirationTime) {
+        return true;
+    }
+    return false;
+};
+
+exports.AUTH_MIN_TOKEN = AUTH_MIN_TOKEN;
+exports.AUTH_MIN_TOKEN_DEMO = AUTH_MIN_TOKEN_DEMO;
+exports.decodeMinJwt = decodeMinJwt;
+exports.getMinAuthToken = getMinAuthToken;
+exports.isCookieEnabled = isCookieEnabled;
+exports.isMinAuthTokenExpired = isMinAuthTokenExpired;
+exports.logger = logger;
+exports.parseToken = parseToken;

package/src/lib/utils/api/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+import { MinifiedDynamicJwt } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;
+export declare const AUTH_MIN_TOKEN = "dynamic_min_authentication_token";
+export declare const AUTH_MIN_TOKEN_DEMO = "dynamic_min_authentication_token_demo";
+export declare const DYNAMIC_STORE_DEMO = "dynamic_store_demo";
+export declare const DYNAMIC_STORE = "dynamic_store";
+export declare const isCookieEnabled: () => any;
+export declare const parseToken: (token: string | null | undefined) => any;
+export declare const decodeMinJwt: (token: string | null | undefined) => Omit<MinifiedDynamicJwt, 'jwt'> | undefined;
+export declare const getMinAuthToken: () => any;
+export declare const isMinAuthTokenExpired: (token: string) => boolean;

package/src/lib/utils/api/utils/helpers.js

@@ -0,0 +1,77 @@
+'use client'
+import { AuthStorageEnum, MinifiedDynamicJwtFromJSON } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+import { LocalStorage } from './LocalStorage.js';
+
+const logger = new Logger('DynamicSDK');
+const AUTH_MIN_TOKEN = 'dynamic_min_authentication_token';
+const AUTH_MIN_TOKEN_DEMO = 'dynamic_min_authentication_token_demo';
+const isCookieEnabled = () => {
+    var _a, _b, _c, _d;
+    let securitySettings = (_a = LocalStorage.getFromLS('dynamic_store')) !== null && _a !== void 0 ? _a : LocalStorage.getFromLS('dynamic_store_demo');
+    securitySettings = (_b = securitySettings === null || securitySettings === void 0 ? void 0 : securitySettings.settings) === null || _b === void 0 ? void 0 : _b.security;
+    if (!securitySettings)
+        return false;
+    // client uses Dynamic cookies
+    const dynamicCookiesEnabled = (((_c = securitySettings.auth) === null || _c === void 0 ? void 0 : _c.storage) || []).includes(AuthStorageEnum.Cookie);
+    // BYO JWT client puts their non-Dynamic JWT in a cookie
+    const byoJwtCookieEnabled = Boolean((_d = securitySettings.externalAuth) === null || _d === void 0 ? void 0 : _d.cookieName);
+    // should return true for both of these scenarios
+    // because we also need to do `credentials: true` in api.ts when
+    // a byo jwt client sets their named cookie for their jwt and
+    // needs to send it to our backend
+    return dynamicCookiesEnabled || byoJwtCookieEnabled;
+};
+const parseToken = (token) => {
+    var _a;
+    if (!token)
+        return undefined;
+    const base64 = (_a = token.split('.')[1]) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = base64 &&
+        decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+            .join(''));
+    return JSON.parse(jsonPayload);
+};
+const decodeMinJwt = (token) => {
+    try {
+        const json = parseToken(token);
+        if (!json)
+            return undefined;
+        return MinifiedDynamicJwtFromJSON(json);
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+};
+const getMinAuthToken = () => {
+    var _a;
+    if (typeof window === 'undefined')
+        return undefined;
+    const token = (_a = LocalStorage.getFromLS(AUTH_MIN_TOKEN, true)) !== null && _a !== void 0 ? _a : LocalStorage.getFromLS(AUTH_MIN_TOKEN_DEMO, true);
+    if (!token || isMinAuthTokenExpired(token))
+        return undefined;
+    return token;
+};
+const isMinAuthTokenExpired = (token) => {
+    const decoded = decodeMinJwt(token);
+    return isTokenExpired(decoded);
+};
+const isTokenExpired = (decoded) => {
+    if (!decoded) {
+        return true;
+    }
+    if (!decoded.exp) {
+        return true;
+    }
+    const expirationTime = new Date(decoded.exp * 1000).getTime();
+    const currentTime = new Date().getTime();
+    if (currentTime >= expirationTime) {
+        return true;
+    }
+    return false;
+};
+
+export { AUTH_MIN_TOKEN, AUTH_MIN_TOKEN_DEMO, decodeMinJwt, getMinAuthToken, isCookieEnabled, isMinAuthTokenExpired, logger, parseToken };

package/src/lib/utils/api/utils/version.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _package = require('../../../../../package.cjs');
+
+const VERSION = _package.version;
+const API_VERSION = _package.dependencies['@dynamic-labs/sdk-api-core'];
+
+exports.API_VERSION = API_VERSION;
+exports.VERSION = VERSION;

package/src/lib/utils/api/utils/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION: string;
+export declare const API_VERSION: string;

package/src/lib/utils/api/utils/version.js

@@ -0,0 +1,7 @@
+'use client'
+import { version, dependencies } from '../../../../../package.js';
+
+const VERSION = version;
+const API_VERSION = dependencies['@dynamic-labs/sdk-api-core'];
+
+export { API_VERSION, VERSION };

package/src/lib/utils/index.d.ts

@@ -1,3 +1,2 @@
 export { createSolanaConnection } from './createSolanaConnection';
-export { getGenesisHashLSKey } from './getGenesisHashLSKey';
 export { decodeTransaction, summarizeTransactionDecodedData, getTotalSolanaSpend, } from './transactionDecoder';